data.real.conjugate_exponents | 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

2196ab36

(last sync)

refactor(algebra/group/basic): rework lemmas on inv and neg (#17483)

This PR adds the following lemma (and its additive equivalent).

theorem inv_eq_iff_eq_inv : a⁻¹ = b ↔ a = b⁻¹

and removes eq_inv_of_eq_inv, eq_inv_iff_eq_inv and inv_eq_iff_inv_eq (and their additive equivalents).

Diff

@@ -68,8 +68,8 @@ ne_of_gt (h.one_div_pos)
 lemma conj_eq : q = p/(p-1) :=
 begin
   have := h.inv_add_inv_conj,
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_inv_eq] at this,
-  field_simp [← this, h.ne_zero]
+  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this,
+  field_simp [this, h.ne_zero]
 end
 
 lemma conjugate_eq : conjugate_exponent p = q := h.conj_eq.symm

bd9851ca

(first ported)

Changes in mathlib3port

mathlib3

mathlib3port

2196ab36

bump to nightly-2024-04-06-08

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

e34029c9

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 -/
-import Data.Real.Ennreal
+import Data.ENNReal.Basic
 
 #align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"

2196ab36

bump to nightly-2024-03-17-08

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

22f01ce4

Diff

@@ -104,7 +104,7 @@ theorem one_div_ne_zero : 1 / p ≠ 0 :=
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this 
+  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
   field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjExponent.conj_eq
 -/

2196ab36

bump to nightly-2024-02-19-08

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

8a61c0bd

Diff

@@ -27,165 +27,164 @@ noncomputable section
 
 namespace Real
 
-#print Real.IsConjugateExponent /-
+#print Real.IsConjExponent /-
 /-- Two real exponents `p, q` are conjugate if they are `> 1` and satisfy the equality
 `1/p + 1/q = 1`. This condition shows up in many theorems in analysis, notably related to `L^p`
 norms. -/
-structure IsConjugateExponent (p q : ℝ) : Prop where
+structure IsConjExponent (p q : ℝ) : Prop where
   one_lt : 1 < p
   inv_add_inv_conj : 1 / p + 1 / q = 1
-#align real.is_conjugate_exponent Real.IsConjugateExponent
+#align real.is_conjugate_exponent Real.IsConjExponent
 -/
 
-#print Real.conjugateExponent /-
+#print Real.conjExponent /-
 /-- The conjugate exponent of `p` is `q = p/(p-1)`, so that `1/p + 1/q = 1`. -/
-def conjugateExponent (p : ℝ) : ℝ :=
+def conjExponent (p : ℝ) : ℝ :=
   p / (p - 1)
-#align real.conjugate_exponent Real.conjugateExponent
+#align real.conjugate_exponent Real.conjExponent
 -/
 
 namespace IsConjugateExponent
 
-variable {p q : ℝ} (h : p.IsConjugateExponent q)
+variable {p q : ℝ} (h : p.IsConjExponent q)
 
-#print Real.IsConjugateExponent.pos /-
+#print Real.IsConjExponent.pos /-
 /- Register several non-vanishing results following from the fact that `p` has a conjugate exponent
 `q`: many computations using these exponents require clearing out denominators, which can be done
 with `field_simp` given a proof that these denominators are non-zero, so we record the most usual
 ones. -/
 theorem pos : 0 < p :=
   lt_trans zero_lt_one h.one_lt
-#align real.is_conjugate_exponent.pos Real.IsConjugateExponent.pos
+#align real.is_conjugate_exponent.pos Real.IsConjExponent.pos
 -/
 
-#print Real.IsConjugateExponent.nonneg /-
+#print Real.IsConjExponent.nonneg /-
 theorem nonneg : 0 ≤ p :=
   le_of_lt h.Pos
-#align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonneg
+#align real.is_conjugate_exponent.nonneg Real.IsConjExponent.nonneg
 -/
 
-#print Real.IsConjugateExponent.ne_zero /-
+#print Real.IsConjExponent.ne_zero /-
 theorem ne_zero : p ≠ 0 :=
   ne_of_gt h.Pos
-#align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zero
+#align real.is_conjugate_exponent.ne_zero Real.IsConjExponent.ne_zero
 -/
 
-#print Real.IsConjugateExponent.sub_one_pos /-
+#print Real.IsConjExponent.sub_one_pos /-
 theorem sub_one_pos : 0 < p - 1 :=
   sub_pos.2 h.one_lt
-#align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_pos
+#align real.is_conjugate_exponent.sub_one_pos Real.IsConjExponent.sub_one_pos
 -/
 
-#print Real.IsConjugateExponent.sub_one_ne_zero /-
+#print Real.IsConjExponent.sub_one_ne_zero /-
 theorem sub_one_ne_zero : p - 1 ≠ 0 :=
   ne_of_gt h.sub_one_pos
-#align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zero
+#align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjExponent.sub_one_ne_zero
 -/
 
-#print Real.IsConjugateExponent.one_div_pos /-
+#print Real.IsConjExponent.one_div_pos /-
 theorem one_div_pos : 0 < 1 / p :=
   one_div_pos.2 h.Pos
-#align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_pos
+#align real.is_conjugate_exponent.one_div_pos Real.IsConjExponent.one_div_pos
 -/
 
-#print Real.IsConjugateExponent.one_div_nonneg /-
+#print Real.IsConjExponent.one_div_nonneg /-
 theorem one_div_nonneg : 0 ≤ 1 / p :=
   le_of_lt h.one_div_pos
-#align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonneg
+#align real.is_conjugate_exponent.one_div_nonneg Real.IsConjExponent.one_div_nonneg
 -/
 
-#print Real.IsConjugateExponent.one_div_ne_zero /-
+#print Real.IsConjExponent.one_div_ne_zero /-
 theorem one_div_ne_zero : 1 / p ≠ 0 :=
   ne_of_gt h.one_div_pos
-#align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zero
+#align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjExponent.one_div_ne_zero
 -/
 
-#print Real.IsConjugateExponent.conj_eq /-
+#print Real.IsConjExponent.conj_eq /-
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
   rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this 
   field_simp [this, h.ne_zero]
-#align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
+#align real.is_conjugate_exponent.conj_eq Real.IsConjExponent.conj_eq
 -/
 
-#print Real.IsConjugateExponent.conjugate_eq /-
-theorem conjugate_eq : conjugateExponent p = q :=
+#print Real.IsConjExponent.conjExponent_eq /-
+theorem conjExponent_eq : conjExponent p = q :=
   h.conj_eq.symm
-#align real.is_conjugate_exponent.conjugate_eq Real.IsConjugateExponent.conjugate_eq
+#align real.is_conjugate_exponent.conjugate_eq Real.IsConjExponent.conjExponent_eq
 -/
 
-#print Real.IsConjugateExponent.sub_one_mul_conj /-
+#print Real.IsConjExponent.sub_one_mul_conj /-
 theorem sub_one_mul_conj : (p - 1) * q = p :=
   mul_comm q (p - 1) ▸ (eq_div_iff h.sub_one_ne_zero).1 h.conj_eq
-#align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conj
+#align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjExponent.sub_one_mul_conj
 -/
 
-#print Real.IsConjugateExponent.mul_eq_add /-
+#print Real.IsConjExponent.mul_eq_add /-
 theorem mul_eq_add : p * q = p + q := by
   simpa only [sub_mul, sub_eq_iff_eq_add, one_mul] using h.sub_one_mul_conj
-#align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_add
+#align real.is_conjugate_exponent.mul_eq_add Real.IsConjExponent.mul_eq_add
 -/
 
-#print Real.IsConjugateExponent.symm /-
+#print Real.IsConjExponent.symm /-
 @[symm]
-protected theorem symm : q.IsConjugateExponent p :=
+protected theorem symm : q.IsConjExponent p :=
   { one_lt := by rw [h.conj_eq]; exact (one_lt_div h.sub_one_pos).mpr (sub_one_lt p)
     inv_add_inv_conj := by simpa [add_comm] using h.inv_add_inv_conj }
-#align real.is_conjugate_exponent.symm Real.IsConjugateExponent.symm
+#align real.is_conjugate_exponent.symm Real.IsConjExponent.symm
 -/
 
-#print Real.IsConjugateExponent.div_conj_eq_sub_one /-
+#print Real.IsConjExponent.div_conj_eq_sub_one /-
 theorem div_conj_eq_sub_one : p / q = p - 1 :=
   by
   field_simp [h.symm.ne_zero]
   rw [h.sub_one_mul_conj]
-#align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
+#align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjExponent.div_conj_eq_sub_one
 -/
 
-#print Real.IsConjugateExponent.one_lt_nnreal /-
-theorem one_lt_nnreal : 1 < Real.toNNReal p :=
+#print NNReal.IsConjExponent.one_lt /-
+theorem one_lt : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
-#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
+#align real.is_conjugate_exponent.one_lt_nnreal NNReal.IsConjExponent.one_lt
 -/
 
-#print Real.IsConjugateExponent.inv_add_inv_conj_nnreal /-
-theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
+#print NNReal.IsConjExponent.inv_add_inv_conj /-
+theorem inv_add_inv_conj : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
+#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal NNReal.IsConjExponent.inv_add_inv_conj
 -/
 
-#print Real.IsConjugateExponent.inv_add_inv_conj_ennreal /-
+#print Real.IsConjExponent.inv_add_inv_conj_ennreal /-
 theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
   rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos, ←
     ENNReal.ofReal_div_of_pos h.symm.pos, ←
     ENNReal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennreal
+#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjExponent.inv_add_inv_conj_ennreal
 -/
 
 end IsConjugateExponent
 
-#print Real.isConjugateExponent_iff /-
-theorem isConjugateExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjugateExponent q ↔ q = p / (p - 1) :=
+#print Real.isConjExponent_iff /-
+theorem isConjExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjExponent q ↔ q = p / (p - 1) :=
   ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)]⟩⟩
-#align real.is_conjugate_exponent_iff Real.isConjugateExponent_iff
+#align real.is_conjugate_exponent_iff Real.isConjExponent_iff
 -/
 
-#print Real.isConjugateExponent_conjugateExponent /-
-theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :
-    p.IsConjugateExponent (conjugateExponent p) :=
-  (isConjugateExponent_iff h).2 rfl
-#align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponent
+#print Real.IsConjExponent.conjExponent /-
+theorem Real.IsConjExponent.conjExponent {p : ℝ} (h : 1 < p) : p.IsConjExponent (conjExponent p) :=
+  (isConjExponent_iff h).2 rfl
+#align real.is_conjugate_exponent_conjugate_exponent Real.IsConjExponent.conjExponent
 -/
 
-#print Real.isConjugateExponent_one_div /-
-theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
-    (1 / a).IsConjugateExponent (1 / b) :=
+#print Real.isConjExponent_one_div /-
+theorem isConjExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
+    (1 / a).IsConjExponent (1 / b) :=
   ⟨by rw [lt_div_iff ha, one_mul]; linarith, by simp_rw [one_div_one_div]; exact hab⟩
-#align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_div
+#align real.is_conjugate_exponent_one_div Real.isConjExponent_one_div
 -/
 
 end Real

2196ab36

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 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 -/
-import Mathbin.Data.Real.Ennreal
+import Data.Real.Ennreal
 
 #align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"

2196ab36

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 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.real.conjugate_exponents
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathbin.Data.Real.Ennreal
 
+#align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
+
 /-!
 # Real conjugate exponents

2196ab36

bump to nightly-2023-06-13-21

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

829520ac

Diff

@@ -51,8 +51,7 @@ namespace IsConjugateExponent
 
 variable {p q : ℝ} (h : p.IsConjugateExponent q)
 
-include h
-
+#print Real.IsConjugateExponent.pos /-
 /- Register several non-vanishing results following from the fact that `p` has a conjugate exponent
 `q`: many computations using these exponents require clearing out denominators, which can be done
 with `field_simp` given a proof that these denominators are non-zero, so we record the most usual
@@ -60,41 +59,58 @@ ones. -/
 theorem pos : 0 < p :=
   lt_trans zero_lt_one h.one_lt
 #align real.is_conjugate_exponent.pos Real.IsConjugateExponent.pos
+-/
 
+#print Real.IsConjugateExponent.nonneg /-
 theorem nonneg : 0 ≤ p :=
   le_of_lt h.Pos
 #align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonneg
+-/
 
+#print Real.IsConjugateExponent.ne_zero /-
 theorem ne_zero : p ≠ 0 :=
   ne_of_gt h.Pos
 #align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zero
+-/
 
+#print Real.IsConjugateExponent.sub_one_pos /-
 theorem sub_one_pos : 0 < p - 1 :=
   sub_pos.2 h.one_lt
 #align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_pos
+-/
 
+#print Real.IsConjugateExponent.sub_one_ne_zero /-
 theorem sub_one_ne_zero : p - 1 ≠ 0 :=
   ne_of_gt h.sub_one_pos
 #align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zero
+-/
 
+#print Real.IsConjugateExponent.one_div_pos /-
 theorem one_div_pos : 0 < 1 / p :=
   one_div_pos.2 h.Pos
 #align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_pos
+-/
 
+#print Real.IsConjugateExponent.one_div_nonneg /-
 theorem one_div_nonneg : 0 ≤ 1 / p :=
   le_of_lt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonneg
+-/
 
+#print Real.IsConjugateExponent.one_div_ne_zero /-
 theorem one_div_ne_zero : 1 / p ≠ 0 :=
   ne_of_gt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zero
+-/
 
+#print Real.IsConjugateExponent.conj_eq /-
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
   rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this 
   field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
+-/
 
 #print Real.IsConjugateExponent.conjugate_eq /-
 theorem conjugate_eq : conjugateExponent p = q :=
@@ -102,13 +118,17 @@ theorem conjugate_eq : conjugateExponent p = q :=
 #align real.is_conjugate_exponent.conjugate_eq Real.IsConjugateExponent.conjugate_eq
 -/
 
+#print Real.IsConjugateExponent.sub_one_mul_conj /-
 theorem sub_one_mul_conj : (p - 1) * q = p :=
   mul_comm q (p - 1) ▸ (eq_div_iff h.sub_one_ne_zero).1 h.conj_eq
 #align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conj
+-/
 
+#print Real.IsConjugateExponent.mul_eq_add /-
 theorem mul_eq_add : p * q = p + q := by
   simpa only [sub_mul, sub_eq_iff_eq_add, one_mul] using h.sub_one_mul_conj
 #align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_add
+-/
 
 #print Real.IsConjugateExponent.symm /-
 @[symm]
@@ -118,11 +138,13 @@ protected theorem symm : q.IsConjugateExponent p :=
 #align real.is_conjugate_exponent.symm Real.IsConjugateExponent.symm
 -/
 
+#print Real.IsConjugateExponent.div_conj_eq_sub_one /-
 theorem div_conj_eq_sub_one : p / q = p - 1 :=
   by
   field_simp [h.symm.ne_zero]
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
+-/
 
 #print Real.IsConjugateExponent.one_lt_nnreal /-
 theorem one_lt_nnreal : 1 < Real.toNNReal p :=
@@ -132,32 +154,42 @@ theorem one_lt_nnreal : 1 < Real.toNNReal p :=
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
 -/
 
+#print Real.IsConjugateExponent.inv_add_inv_conj_nnreal /-
 theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
+-/
 
+#print Real.IsConjugateExponent.inv_add_inv_conj_ennreal /-
 theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
   rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos, ←
     ENNReal.ofReal_div_of_pos h.symm.pos, ←
     ENNReal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennreal
+-/
 
 end IsConjugateExponent
 
+#print Real.isConjugateExponent_iff /-
 theorem isConjugateExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjugateExponent q ↔ q = p / (p - 1) :=
   ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)]⟩⟩
 #align real.is_conjugate_exponent_iff Real.isConjugateExponent_iff
+-/
 
+#print Real.isConjugateExponent_conjugateExponent /-
 theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :
     p.IsConjugateExponent (conjugateExponent p) :=
   (isConjugateExponent_iff h).2 rfl
 #align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponent
+-/
 
+#print Real.isConjugateExponent_one_div /-
 theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
     (1 / a).IsConjugateExponent (1 / b) :=
   ⟨by rw [lt_div_iff ha, one_mul]; linarith, by simp_rw [one_div_one_div]; exact hab⟩
 #align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_div
+-/
 
 end Real

2196ab36

bump to nightly-2023-06-01-16

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

b9c87c70

Diff

@@ -92,7 +92,7 @@ theorem one_div_ne_zero : 1 / p ≠ 0 :=
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
+  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this 
   field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
 
@@ -146,7 +146,7 @@ theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q =
 end IsConjugateExponent
 
 theorem isConjugateExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjugateExponent q ↔ q = p / (p - 1) :=
-  ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)] ⟩⟩
+  ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)]⟩⟩
 #align real.is_conjugate_exponent_iff Real.isConjugateExponent_iff
 
 theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :

2196ab36

bump to nightly-2023-05-28-18

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

8d353152

Diff

@@ -124,11 +124,13 @@ theorem div_conj_eq_sub_one : p / q = p - 1 :=
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
+#print Real.IsConjugateExponent.one_lt_nnreal /-
 theorem one_lt_nnreal : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
+-/
 
 theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←

2196ab36

bump to nightly-2023-05-28-06

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

ba5d8b97

Diff

@@ -53,12 +53,6 @@ variable {p q : ℝ} (h : p.IsConjugateExponent q)
 
 include h
 
-/- warning: real.is_conjugate_exponent.pos -> Real.IsConjugateExponent.pos is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) p)
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) p)
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.pos Real.IsConjugateExponent.posₓ'. -/
 /- Register several non-vanishing results following from the fact that `p` has a conjugate exponent
 `q`: many computations using these exponents require clearing out denominators, which can be done
 with `field_simp` given a proof that these denominators are non-zero, so we record the most usual
@@ -67,82 +61,34 @@ theorem pos : 0 < p :=
   lt_trans zero_lt_one h.one_lt
 #align real.is_conjugate_exponent.pos Real.IsConjugateExponent.pos
 
-/- warning: real.is_conjugate_exponent.nonneg -> Real.IsConjugateExponent.nonneg is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) p)
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) p)
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonnegₓ'. -/
 theorem nonneg : 0 ≤ p :=
   le_of_lt h.Pos
 #align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonneg
 
-/- warning: real.is_conjugate_exponent.ne_zero -> Real.IsConjugateExponent.ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real p (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real p (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zeroₓ'. -/
 theorem ne_zero : p ≠ 0 :=
   ne_of_gt h.Pos
 #align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zero
 
-/- warning: real.is_conjugate_exponent.sub_one_pos -> Real.IsConjugateExponent.sub_one_pos is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_posₓ'. -/
 theorem sub_one_pos : 0 < p - 1 :=
   sub_pos.2 h.one_lt
 #align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_pos
 
-/- warning: real.is_conjugate_exponent.sub_one_ne_zero -> Real.IsConjugateExponent.sub_one_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zeroₓ'. -/
 theorem sub_one_ne_zero : p - 1 ≠ 0 :=
   ne_of_gt h.sub_one_pos
 #align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zero
 
-/- warning: real.is_conjugate_exponent.one_div_pos -> Real.IsConjugateExponent.one_div_pos is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_posₓ'. -/
 theorem one_div_pos : 0 < 1 / p :=
   one_div_pos.2 h.Pos
 #align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_pos
 
-/- warning: real.is_conjugate_exponent.one_div_nonneg -> Real.IsConjugateExponent.one_div_nonneg is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonnegₓ'. -/
 theorem one_div_nonneg : 0 ≤ 1 / p :=
   le_of_lt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonneg
 
-/- warning: real.is_conjugate_exponent.one_div_ne_zero -> Real.IsConjugateExponent.one_div_ne_zero is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zeroₓ'. -/
 theorem one_div_ne_zero : 1 / p ≠ 0 :=
   ne_of_gt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zero
 
-/- warning: real.is_conjugate_exponent.conj_eq -> Real.IsConjugateExponent.conj_eq is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eqₓ'. -/
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
@@ -156,22 +102,10 @@ theorem conjugate_eq : conjugateExponent p = q :=
 #align real.is_conjugate_exponent.conjugate_eq Real.IsConjugateExponent.conjugate_eq
 -/
 
-/- warning: real.is_conjugate_exponent.sub_one_mul_conj -> Real.IsConjugateExponent.sub_one_mul_conj is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) q) p)
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) q) p)
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conjₓ'. -/
 theorem sub_one_mul_conj : (p - 1) * q = p :=
   mul_comm q (p - 1) ▸ (eq_div_iff h.sub_one_ne_zero).1 h.conj_eq
 #align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conj
 
-/- warning: real.is_conjugate_exponent.mul_eq_add -> Real.IsConjugateExponent.mul_eq_add is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) p q) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) p q))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) p q) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) p q))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_addₓ'. -/
 theorem mul_eq_add : p * q = p + q := by
   simpa only [sub_mul, sub_eq_iff_eq_add, one_mul] using h.sub_one_mul_conj
 #align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_add
@@ -184,47 +118,23 @@ protected theorem symm : q.IsConjugateExponent p :=
 #align real.is_conjugate_exponent.symm Real.IsConjugateExponent.symm
 -/
 
-/- warning: real.is_conjugate_exponent.div_conj_eq_sub_one -> Real.IsConjugateExponent.div_conj_eq_sub_one is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p q) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p q) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_oneₓ'. -/
 theorem div_conj_eq_sub_one : p / q = p - 1 :=
   by
   field_simp [h.symm.ne_zero]
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
-/- warning: real.is_conjugate_exponent.one_lt_nnreal -> Real.IsConjugateExponent.one_lt_nnreal is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal p))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal p))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnrealₓ'. -/
 theorem one_lt_nnreal : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
 
-/- warning: real.is_conjugate_exponent.inv_add_inv_conj_nnreal -> Real.IsConjugateExponent.inv_add_inv_conj_nnreal is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnrealₓ'. -/
 theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
 
-/- warning: real.is_conjugate_exponent.inv_add_inv_conj_ennreal -> Real.IsConjugateExponent.inv_add_inv_conj_ennreal is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} ENNReal (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toHasDiv.{0} ENNReal ENNReal.divInvMonoid)) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))) (ENNReal.ofReal p)) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toHasDiv.{0} ENNReal ENNReal.divInvMonoid)) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))) (ENNReal.ofReal q))) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} ENNReal (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toDiv.{0} ENNReal ENNReal.instDivInvMonoidENNReal)) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.ofReal p)) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toDiv.{0} ENNReal ENNReal.instDivInvMonoidENNReal)) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.ofReal q))) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennrealₓ'. -/
 theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
   rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos, ←
     ENNReal.ofReal_div_of_pos h.symm.pos, ←
@@ -233,33 +143,15 @@ theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q =
 
 end IsConjugateExponent
 
-/- warning: real.is_conjugate_exponent_iff -> Real.isConjugateExponent_iff is a dubious translation:
-lean 3 declaration is
-  forall {p : Real} {q : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) -> (Iff (Real.IsConjugateExponent p q) (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))))
-but is expected to have type
-  forall {p : Real} {q : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) -> (Iff (Real.IsConjugateExponent p q) (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_iff Real.isConjugateExponent_iffₓ'. -/
 theorem isConjugateExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjugateExponent q ↔ q = p / (p - 1) :=
   ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)] ⟩⟩
 #align real.is_conjugate_exponent_iff Real.isConjugateExponent_iff
 
-/- warning: real.is_conjugate_exponent_conjugate_exponent -> Real.isConjugateExponent_conjugateExponent is a dubious translation:
-lean 3 declaration is
-  forall {p : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) -> (Real.IsConjugateExponent p (Real.conjugateExponent p))
-but is expected to have type
-  forall {p : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) -> (Real.IsConjugateExponent p (Real.conjugateExponent p))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponentₓ'. -/
 theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :
     p.IsConjugateExponent (conjugateExponent p) :=
   (isConjugateExponent_iff h).2 rfl
 #align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponent
 
-/- warning: real.is_conjugate_exponent_one_div -> Real.isConjugateExponent_one_div is a dubious translation:
-lean 3 declaration is
-  forall {a : Real} {b : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) a) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) b) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) a b) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) -> (Real.IsConjugateExponent (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) a) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) b))
-but is expected to have type
-  forall {a : Real} {b : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) a) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) b) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) a b) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) -> (Real.IsConjugateExponent (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) a) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) b))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_divₓ'. -/
 theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
     (1 / a).IsConjugateExponent (1 / b) :=
   ⟨by rw [lt_div_iff ha, one_mul]; linarith, by simp_rw [one_div_one_div]; exact hab⟩

2196ab36

bump to nightly-2023-05-28-04

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

6797a637

Diff

@@ -179,9 +179,7 @@ theorem mul_eq_add : p * q = p + q := by
 #print Real.IsConjugateExponent.symm /-
 @[symm]
 protected theorem symm : q.IsConjugateExponent p :=
-  { one_lt := by
-      rw [h.conj_eq]
-      exact (one_lt_div h.sub_one_pos).mpr (sub_one_lt p)
+  { one_lt := by rw [h.conj_eq]; exact (one_lt_div h.sub_one_pos).mpr (sub_one_lt p)
     inv_add_inv_conj := by simpa [add_comm] using h.inv_add_inv_conj }
 #align real.is_conjugate_exponent.symm Real.IsConjugateExponent.symm
 -/
@@ -264,11 +262,7 @@ but is expected to have type
 Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_divₓ'. -/
 theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
     (1 / a).IsConjugateExponent (1 / b) :=
-  ⟨by
-    rw [lt_div_iff ha, one_mul]
-    linarith, by
-    simp_rw [one_div_one_div]
-    exact hab⟩
+  ⟨by rw [lt_div_iff ha, one_mul]; linarith, by simp_rw [one_div_one_div]; exact hab⟩
 #align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_div
 
 end Real

2196ab36

bump to nightly-2023-05-16-16

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

9cb92e8c

Diff

@@ -198,13 +198,17 @@ theorem div_conj_eq_sub_one : p / q = p - 1 :=
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
-#print Real.IsConjugateExponent.one_lt_nnreal /-
+/- warning: real.is_conjugate_exponent.one_lt_nnreal -> Real.IsConjugateExponent.one_lt_nnreal is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} NNReal (Preorder.toHasLt.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (OrderedCancelAddCommMonoid.toPartialOrder.{0} NNReal (StrictOrderedSemiring.toOrderedCancelAddCommMonoid.{0} NNReal NNReal.strictOrderedSemiring)))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal p))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} NNReal (Preorder.toLT.{0} NNReal (PartialOrder.toPreorder.{0} NNReal (StrictOrderedSemiring.toPartialOrder.{0} NNReal instNNRealStrictOrderedSemiring))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal p))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnrealₓ'. -/
 theorem one_lt_nnreal : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
--/
 
 /- warning: real.is_conjugate_exponent.inv_add_inv_conj_nnreal -> Real.IsConjugateExponent.inv_add_inv_conj_nnreal is a dubious translation:
 lean 3 declaration is

2196ab36

bump to nightly-2023-04-22-04

mathlib commit https://github.com/leanprover-community/mathlib/commit/52932b3a083d4142e78a15dc928084a22fea9ba0

21c163d5

Diff

@@ -198,24 +198,24 @@ theorem div_conj_eq_sub_one : p / q = p - 1 :=
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
-#print Real.IsConjugateExponent.one_lt_nNReal /-
-theorem one_lt_nNReal : 1 < Real.toNNReal p :=
+#print Real.IsConjugateExponent.one_lt_nnreal /-
+theorem one_lt_nnreal : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
-#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nNReal
+#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
 -/
 
-/- warning: real.is_conjugate_exponent.inv_add_inv_conj_nnreal -> Real.IsConjugateExponent.inv_add_inv_conj_nNReal is a dubious translation:
+/- warning: real.is_conjugate_exponent.inv_add_inv_conj_nnreal -> Real.IsConjugateExponent.inv_add_inv_conj_nnreal is a dubious translation:
 lean 3 declaration is
   forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
 but is expected to have type
   forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)))
-Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNRealₓ'. -/
-theorem inv_add_inv_conj_nNReal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnrealₓ'. -/
+theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNReal
+#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
 
 /- warning: real.is_conjugate_exponent.inv_add_inv_conj_ennreal -> Real.IsConjugateExponent.inv_add_inv_conj_ennreal is a dubious translation:
 lean 3 declaration is

2196ab36

bump to nightly-2023-03-14-02

mathlib commit https://github.com/leanprover-community/mathlib/commit/2196ab363eb097c008d4497125e0dde23fb36db2

d4b38a42

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.real.conjugate_exponents
-! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -146,8 +146,8 @@ Case conversion may be inaccurate. Consider using '#align real.is_conjugate_expo
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_inv_eq] at this
-  field_simp [← this, h.ne_zero]
+  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
+  field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
 
 #print Real.IsConjugateExponent.conjugate_eq /-

ee05e9ce

bump to nightly-2023-03-02-03

mathlib commit https://github.com/leanprover-community/mathlib/commit/195fcd60ff2bfe392543bceb0ec2adcdb472db4c

db7421c3

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.real.conjugate_exponents
-! leanprover-community/mathlib commit 52e2fbbd9b519e6981e4b53aedb26a2d52548d3a
+! leanprover-community/mathlib commit ee05e9ce1322178f0c12004eb93c00d2c8c00ed2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -13,6 +13,9 @@ import Mathbin.Data.Real.Ennreal
 /-!
 # Real conjugate exponents
 
+> THIS FILE IS SYNCHRONIZED WITH MATHLIB4.
+> Any changes to this file require a corresponding PR to mathlib4.
+
 `p.is_conjugate_exponent q` registers the fact that the real numbers `p` and `q` are `> 1` and
 satisfy `1/p + 1/q = 1`. This property shows up often in analysis, especially when dealing with
 `L^p` spaces.

52e2fbbd

bump to nightly-2023-02-28-12

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

208d1f40

Diff

@@ -27,6 +27,7 @@ noncomputable section
 
 namespace Real
 
+#print Real.IsConjugateExponent /-
 /-- Two real exponents `p, q` are conjugate if they are `> 1` and satisfy the equality
 `1/p + 1/q = 1`. This condition shows up in many theorems in analysis, notably related to `L^p`
 norms. -/
@@ -34,11 +35,14 @@ structure IsConjugateExponent (p q : ℝ) : Prop where
   one_lt : 1 < p
   inv_add_inv_conj : 1 / p + 1 / q = 1
 #align real.is_conjugate_exponent Real.IsConjugateExponent
+-/
 
+#print Real.conjugateExponent /-
 /-- The conjugate exponent of `p` is `q = p/(p-1)`, so that `1/p + 1/q = 1`. -/
 def conjugateExponent (p : ℝ) : ℝ :=
   p / (p - 1)
 #align real.conjugate_exponent Real.conjugateExponent
+-/
 
 namespace IsConjugateExponent
 
@@ -46,6 +50,12 @@ variable {p q : ℝ} (h : p.IsConjugateExponent q)
 
 include h
 
+/- warning: real.is_conjugate_exponent.pos -> Real.IsConjugateExponent.pos is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) p)
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) p)
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.pos Real.IsConjugateExponent.posₓ'. -/
 /- Register several non-vanishing results following from the fact that `p` has a conjugate exponent
 `q`: many computations using these exponents require clearing out denominators, which can be done
 with `field_simp` given a proof that these denominators are non-zero, so we record the most usual
@@ -54,34 +64,82 @@ theorem pos : 0 < p :=
   lt_trans zero_lt_one h.one_lt
 #align real.is_conjugate_exponent.pos Real.IsConjugateExponent.pos
 
+/- warning: real.is_conjugate_exponent.nonneg -> Real.IsConjugateExponent.nonneg is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) p)
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) p)
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonnegₓ'. -/
 theorem nonneg : 0 ≤ p :=
   le_of_lt h.Pos
 #align real.is_conjugate_exponent.nonneg Real.IsConjugateExponent.nonneg
 
+/- warning: real.is_conjugate_exponent.ne_zero -> Real.IsConjugateExponent.ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real p (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real p (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zeroₓ'. -/
 theorem ne_zero : p ≠ 0 :=
   ne_of_gt h.Pos
 #align real.is_conjugate_exponent.ne_zero Real.IsConjugateExponent.ne_zero
 
+/- warning: real.is_conjugate_exponent.sub_one_pos -> Real.IsConjugateExponent.sub_one_pos is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_posₓ'. -/
 theorem sub_one_pos : 0 < p - 1 :=
   sub_pos.2 h.one_lt
 #align real.is_conjugate_exponent.sub_one_pos Real.IsConjugateExponent.sub_one_pos
 
+/- warning: real.is_conjugate_exponent.sub_one_ne_zero -> Real.IsConjugateExponent.sub_one_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zeroₓ'. -/
 theorem sub_one_ne_zero : p - 1 ≠ 0 :=
   ne_of_gt h.sub_one_pos
 #align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zero
 
+/- warning: real.is_conjugate_exponent.one_div_pos -> Real.IsConjugateExponent.one_div_pos is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_posₓ'. -/
 theorem one_div_pos : 0 < 1 / p :=
   one_div_pos.2 h.Pos
 #align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_pos
 
+/- warning: real.is_conjugate_exponent.one_div_nonneg -> Real.IsConjugateExponent.one_div_nonneg is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.hasLe (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (LE.le.{0} Real Real.instLEReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonnegₓ'. -/
 theorem one_div_nonneg : 0 ≤ 1 / p :=
   le_of_lt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_nonneg Real.IsConjugateExponent.one_div_nonneg
 
+/- warning: real.is_conjugate_exponent.one_div_ne_zero -> Real.IsConjugateExponent.one_div_ne_zero is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Ne.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zeroₓ'. -/
 theorem one_div_ne_zero : 1 / p ≠ 0 :=
   ne_of_gt h.one_div_pos
 #align real.is_conjugate_exponent.one_div_ne_zero Real.IsConjugateExponent.one_div_ne_zero
 
+/- warning: real.is_conjugate_exponent.conj_eq -> Real.IsConjugateExponent.conj_eq is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)))))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eqₓ'. -/
 theorem conj_eq : q = p / (p - 1) :=
   by
   have := h.inv_add_inv_conj
@@ -89,18 +147,33 @@ theorem conj_eq : q = p / (p - 1) :=
   field_simp [← this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
 
+#print Real.IsConjugateExponent.conjugate_eq /-
 theorem conjugate_eq : conjugateExponent p = q :=
   h.conj_eq.symm
 #align real.is_conjugate_exponent.conjugate_eq Real.IsConjugateExponent.conjugate_eq
+-/
 
+/- warning: real.is_conjugate_exponent.sub_one_mul_conj -> Real.IsConjugateExponent.sub_one_mul_conj is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) q) p)
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) q) p)
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conjₓ'. -/
 theorem sub_one_mul_conj : (p - 1) * q = p :=
   mul_comm q (p - 1) ▸ (eq_div_iff h.sub_one_ne_zero).1 h.conj_eq
 #align real.is_conjugate_exponent.sub_one_mul_conj Real.IsConjugateExponent.sub_one_mul_conj
 
+/- warning: real.is_conjugate_exponent.mul_eq_add -> Real.IsConjugateExponent.mul_eq_add is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.hasMul) p q) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) p q))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HMul.hMul.{0, 0, 0} Real Real Real (instHMul.{0} Real Real.instMulReal) p q) (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) p q))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_addₓ'. -/
 theorem mul_eq_add : p * q = p + q := by
   simpa only [sub_mul, sub_eq_iff_eq_add, one_mul] using h.sub_one_mul_conj
 #align real.is_conjugate_exponent.mul_eq_add Real.IsConjugateExponent.mul_eq_add
 
+#print Real.IsConjugateExponent.symm /-
 @[symm]
 protected theorem symm : q.IsConjugateExponent p :=
   { one_lt := by
@@ -108,41 +181,80 @@ protected theorem symm : q.IsConjugateExponent p :=
       exact (one_lt_div h.sub_one_pos).mpr (sub_one_lt p)
     inv_add_inv_conj := by simpa [add_comm] using h.inv_add_inv_conj }
 #align real.is_conjugate_exponent.symm Real.IsConjugateExponent.symm
+-/
 
+/- warning: real.is_conjugate_exponent.div_conj_eq_sub_one -> Real.IsConjugateExponent.div_conj_eq_sub_one is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p q) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} Real (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p q) (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_oneₓ'. -/
 theorem div_conj_eq_sub_one : p / q = p - 1 :=
   by
   field_simp [h.symm.ne_zero]
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
+#print Real.IsConjugateExponent.one_lt_nNReal /-
 theorem one_lt_nNReal : 1 < Real.toNNReal p :=
   by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nNReal
+-/
 
+/- warning: real.is_conjugate_exponent.inv_add_inv_conj_nnreal -> Real.IsConjugateExponent.inv_add_inv_conj_nNReal is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toHasAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal NNReal.hasDiv) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (OfNat.mk.{0} NNReal 1 (One.one.{0} NNReal (AddMonoidWithOne.toOne.{0} NNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} NNReal (NonAssocSemiring.toAddCommMonoidWithOne.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal NNReal.semiring))))))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} NNReal (HAdd.hAdd.{0, 0, 0} NNReal NNReal NNReal (instHAdd.{0} NNReal (Distrib.toAdd.{0} NNReal (NonUnitalNonAssocSemiring.toDistrib.{0} NNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} NNReal (Semiring.toNonAssocSemiring.{0} NNReal instNNRealSemiring))))) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal p)) (HDiv.hDiv.{0, 0, 0} NNReal NNReal NNReal (instHDiv.{0} NNReal (CanonicallyLinearOrderedSemifield.toDiv.{0} NNReal NNReal.instCanonicallyLinearOrderedSemifieldNNReal)) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)) (Real.toNNReal q))) (OfNat.ofNat.{0} NNReal 1 (One.toOfNat1.{0} NNReal instNNRealOne)))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNRealₓ'. -/
 theorem inv_add_inv_conj_nNReal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg, ←
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNReal
 
-theorem inv_add_inv_conj_eNNReal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
+/- warning: real.is_conjugate_exponent.inv_add_inv_conj_ennreal -> Real.IsConjugateExponent.inv_add_inv_conj_ennreal is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} ENNReal (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toHasAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.canonicallyOrderedCommSemiring)))))))) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toHasDiv.{0} ENNReal ENNReal.divInvMonoid)) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))) (ENNReal.ofReal p)) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toHasDiv.{0} ENNReal ENNReal.divInvMonoid)) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))) (ENNReal.ofReal q))) (OfNat.ofNat.{0} ENNReal 1 (OfNat.mk.{0} ENNReal 1 (One.one.{0} ENNReal (AddMonoidWithOne.toOne.{0} ENNReal (AddCommMonoidWithOne.toAddMonoidWithOne.{0} ENNReal ENNReal.addCommMonoidWithOne))))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (Real.IsConjugateExponent p q) -> (Eq.{1} ENNReal (HAdd.hAdd.{0, 0, 0} ENNReal ENNReal ENNReal (instHAdd.{0} ENNReal (Distrib.toAdd.{0} ENNReal (NonUnitalNonAssocSemiring.toDistrib.{0} ENNReal (NonAssocSemiring.toNonUnitalNonAssocSemiring.{0} ENNReal (Semiring.toNonAssocSemiring.{0} ENNReal (OrderedSemiring.toSemiring.{0} ENNReal (OrderedCommSemiring.toOrderedSemiring.{0} ENNReal (CanonicallyOrderedCommSemiring.toOrderedCommSemiring.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal)))))))) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toDiv.{0} ENNReal ENNReal.instDivInvMonoidENNReal)) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.ofReal p)) (HDiv.hDiv.{0, 0, 0} ENNReal ENNReal ENNReal (instHDiv.{0} ENNReal (DivInvMonoid.toDiv.{0} ENNReal ENNReal.instDivInvMonoidENNReal)) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))) (ENNReal.ofReal q))) (OfNat.ofNat.{0} ENNReal 1 (One.toOfNat1.{0} ENNReal (CanonicallyOrderedCommSemiring.toOne.{0} ENNReal ENNReal.instCanonicallyOrderedCommSemiringENNReal))))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennrealₓ'. -/
+theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
   rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos, ←
     ENNReal.ofReal_div_of_pos h.symm.pos, ←
     ENNReal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_eNNReal
+#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennreal
 
 end IsConjugateExponent
 
+/- warning: real.is_conjugate_exponent_iff -> Real.isConjugateExponent_iff is a dubious translation:
+lean 3 declaration is
+  forall {p : Real} {q : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) -> (Iff (Real.IsConjugateExponent p q) (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.hasSub) p (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))))))
+but is expected to have type
+  forall {p : Real} {q : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) -> (Iff (Real.IsConjugateExponent p q) (Eq.{1} Real q (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) p (HSub.hSub.{0, 0, 0} Real Real Real (instHSub.{0} Real Real.instSubReal) p (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))))))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_iff Real.isConjugateExponent_iffₓ'. -/
 theorem isConjugateExponent_iff {p q : ℝ} (h : 1 < p) : p.IsConjugateExponent q ↔ q = p / (p - 1) :=
   ⟨fun H => H.conj_eq, fun H => ⟨h, by field_simp [H, ne_of_gt (lt_trans zero_lt_one h)] ⟩⟩
 #align real.is_conjugate_exponent_iff Real.isConjugateExponent_iff
 
+/- warning: real.is_conjugate_exponent_conjugate_exponent -> Real.isConjugateExponent_conjugateExponent is a dubious translation:
+lean 3 declaration is
+  forall {p : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) p) -> (Real.IsConjugateExponent p (Real.conjugateExponent p))
+but is expected to have type
+  forall {p : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) p) -> (Real.IsConjugateExponent p (Real.conjugateExponent p))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponentₓ'. -/
 theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :
     p.IsConjugateExponent (conjugateExponent p) :=
   (isConjugateExponent_iff h).2 rfl
 #align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponent
 
+/- warning: real.is_conjugate_exponent_one_div -> Real.isConjugateExponent_one_div is a dubious translation:
+lean 3 declaration is
+  forall {a : Real} {b : Real}, (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) a) -> (LT.lt.{0} Real Real.hasLt (OfNat.ofNat.{0} Real 0 (OfNat.mk.{0} Real 0 (Zero.zero.{0} Real Real.hasZero))) b) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.hasAdd) a b) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne)))) -> (Real.IsConjugateExponent (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) a) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (DivInvMonoid.toHasDiv.{0} Real (DivisionRing.toDivInvMonoid.{0} Real Real.divisionRing))) (OfNat.ofNat.{0} Real 1 (OfNat.mk.{0} Real 1 (One.one.{0} Real Real.hasOne))) b))
+but is expected to have type
+  forall {a : Real} {b : Real}, (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) a) -> (LT.lt.{0} Real Real.instLTReal (OfNat.ofNat.{0} Real 0 (Zero.toOfNat0.{0} Real Real.instZeroReal)) b) -> (Eq.{1} Real (HAdd.hAdd.{0, 0, 0} Real Real Real (instHAdd.{0} Real Real.instAddReal) a b) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal))) -> (Real.IsConjugateExponent (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) a) (HDiv.hDiv.{0, 0, 0} Real Real Real (instHDiv.{0} Real (LinearOrderedField.toDiv.{0} Real Real.instLinearOrderedFieldReal)) (OfNat.ofNat.{0} Real 1 (One.toOfNat1.{0} Real Real.instOneReal)) b))
+Case conversion may be inaccurate. Consider using '#align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_divₓ'. -/
 theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
     (1 / a).IsConjugateExponent (1 / b) :=
   ⟨by

52e2fbbd

bump to nightly-2023-02-27-10

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

49ff026a

Diff

@@ -126,11 +126,11 @@ theorem inv_add_inv_conj_nNReal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1
     Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNReal
 
-theorem inv_add_inv_conj_ennreal : 1 / Ennreal.ofReal p + 1 / Ennreal.ofReal q = 1 := by
-  rw [← Ennreal.ofReal_one, ← Ennreal.ofReal_div_of_pos h.pos, ←
-    Ennreal.ofReal_div_of_pos h.symm.pos, ←
-    Ennreal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennreal
+theorem inv_add_inv_conj_eNNReal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
+  rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos, ←
+    ENNReal.ofReal_div_of_pos h.symm.pos, ←
+    ENNReal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
+#align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_eNNReal
 
 end IsConjugateExponent

52e2fbbd

bump to nightly-2023-02-21-16

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

1107b979

Changes in mathlib4

mathlib3

mathlib4

2196ab36

chore: Rename mul-div cancellation lemmas (#11530)

Lemma names around cancellation of multiplication and division are a mess.

This PR renames a handful of them according to the following table (each big row contains the multiplicative statement, then the three rows contain the GroupWithZero lemma name, the Group lemma, the AddGroup lemma name).

4ea4a86a

Diff

@@ -92,7 +92,7 @@ lemma conjExponent_eq : conjExponent p = q := h.conj_eq.symm
 #align real.is_conjugate_exponent.conjugate_eq Real.IsConjExponent.conjExponent_eq
 
 lemma one_sub_inv : 1 - p⁻¹ = q⁻¹ := sub_eq_of_eq_add' h.inv_add_inv_conj.symm
-lemma inv_sub_one : p⁻¹ - 1 = -q⁻¹ := by rw [← h.inv_add_inv_conj, sub_add_cancel']
+lemma inv_sub_one : p⁻¹ - 1 = -q⁻¹ := by rw [← h.inv_add_inv_conj, sub_add_cancel_left]
 
 theorem sub_one_mul_conj : (p - 1) * q = p :=
   mul_comm q (p - 1) ▸ (eq_div_iff h.sub_one_ne_zero).1 h.conj_eq

2196ab36

feat: Conjugate exponents in ℝ≥0 (#10589)

It happens often that we have p q : ℝ≥0 that are conjugate. So far, we only had a predicate for real numbers to be conjugate, which made dealing with ℝ≥0 conjugates clumsy.

This PR

introduces NNReal.IsConjExponent, NNReal.conjExponent
renames Real.IsConjugateExponent, Real.conjugateExponent to Real.IsConjExponent, Real.conjExponent
renames a few more lemmas to match up the Real and NNReal versions

From LeanAPAP

d02cf66e

2196ab36

refactor: Use p⁻¹ instead of 1 / p in conjugate exponents (#10216)

I am keeping some 1 / p lemmas behind to keep the diff small but the goal is to get rid of them entirely.

129c0e0e

Diff

@@ -17,6 +17,10 @@ satisfy `1/p + 1/q = 1`. This property shows up often in analysis, especially wh
 We make several basic facts available through dot notation in this situation.
 
 We also introduce `p.conjugateExponent` for `p / (p-1)`. When `p > 1`, it is conjugate to `p`.
+
+## TODO
+
+Eradicate the `1 / p` spelling in lemmas.
 -/
 
 
@@ -29,7 +33,7 @@ namespace Real
 norms. -/
 structure IsConjugateExponent (p q : ℝ) : Prop where
   one_lt : 1 < p
-  inv_add_inv_conj : 1 / p + 1 / q = 1
+  inv_add_inv_conj : p⁻¹ + q⁻¹ = 1
 #align real.is_conjugate_exponent Real.IsConjugateExponent
 
 /-- The conjugate exponent of `p` is `q = p/(p-1)`, so that `1/p + 1/q = 1`. -/
@@ -59,6 +63,10 @@ theorem sub_one_pos : 0 < p - 1 := sub_pos.2 h.one_lt
 theorem sub_one_ne_zero : p - 1 ≠ 0 := ne_of_gt h.sub_one_pos
 #align real.is_conjugate_exponent.sub_one_ne_zero Real.IsConjugateExponent.sub_one_ne_zero
 
+protected lemma inv_pos : 0 < p⁻¹ := inv_pos.2 h.pos
+protected lemma inv_nonneg : 0 ≤ p⁻¹ := h.inv_pos.le
+protected lemma inv_ne_zero : p⁻¹ ≠ 0 := h.inv_pos.ne'
+
 theorem one_div_pos : 0 < 1 / p := _root_.one_div_pos.2 h.pos
 #align real.is_conjugate_exponent.one_div_pos Real.IsConjugateExponent.one_div_pos
 
@@ -70,7 +78,7 @@ theorem one_div_ne_zero : 1 / p ≠ 0 := ne_of_gt h.one_div_pos
 
 theorem conj_eq : q = p / (p - 1) := by
   have := h.inv_add_inv_conj
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
+  rw [← eq_sub_iff_add_eq', inv_eq_iff_eq_inv] at this
   field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
 
@@ -103,15 +111,15 @@ theorem one_lt_nnreal : 1 < Real.toNNReal p := by
   exact h.one_lt
 #align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
 
-theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
-  rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg,
-      ← Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
+theorem inv_add_inv_conj_nnreal : p.toNNReal⁻¹ + q.toNNReal⁻¹ = 1 := by
+  rw [← Real.toNNReal_one, ← Real.toNNReal_inv, ← Real.toNNReal_inv,
+      ← Real.toNNReal_add h.inv_nonneg h.symm.inv_nonneg, h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
 
-theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
-  rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos,
-      ← ENNReal.ofReal_div_of_pos h.symm.pos,
-      ← ENNReal.ofReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
+theorem inv_add_inv_conj_ennreal : (ENNReal.ofReal p)⁻¹ + (ENNReal.ofReal q)⁻¹ = 1 := by
+  rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_inv_of_pos h.pos,
+    ← ENNReal.ofReal_inv_of_pos h.symm.pos, ← ENNReal.ofReal_add h.inv_nonneg h.symm.inv_nonneg,
+    h.inv_add_inv_conj]
 #align real.is_conjugate_exponent.inv_add_inv_conj_ennreal Real.IsConjugateExponent.inv_add_inv_conj_ennreal
 
 end IsConjugateExponent
@@ -124,10 +132,11 @@ theorem isConjugateExponent_conjugateExponent {p : ℝ} (h : 1 < p) :
     p.IsConjugateExponent (conjugateExponent p) := (isConjugateExponent_iff h).2 rfl
 #align real.is_conjugate_exponent_conjugate_exponent Real.isConjugateExponent_conjugateExponent
 
+lemma isConjugateExponent_inv {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
+    a⁻¹.IsConjugateExponent b⁻¹ := ⟨one_lt_inv ha $ by linarith, by simpa only [inv_inv]⟩
+
 theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab : a + b = 1) :
-    (1 / a).IsConjugateExponent (1 / b) :=
-  ⟨by rw [lt_div_iff ha, one_mul]; linarith,
-   by simp_rw [one_div_one_div]; exact hab⟩
+    (1 / a).IsConjugateExponent (1 / b) := by simpa using isConjugateExponent_inv ha hb hab
 #align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_div
 
 end Real

2196ab36

chore(Data/ENNReal/Basic): split file (#9869)

Co-authored-by: Jireh Loreaux <loreaujy@gmail.com>

f9daa988

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 -/
-import Mathlib.Data.ENNReal.Basic
+import Mathlib.Data.ENNReal.Real
 
 #align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"

2196ab36

chore(Data/Real/ENNReal): move to Data/ENNReal/Basic (#9823)

In preparation for splitting that file. Location suggested by @j-loreaux on zulip.

07c91e91

Diff

@@ -3,7 +3,7 @@ Copyright (c) 2020 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 -/
-import Mathlib.Data.Real.ENNReal
+import Mathlib.Data.ENNReal.Basic
 
 #align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"

2196ab36

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

depends on: #5966

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

89aa3a3b

Diff

@@ -2,14 +2,11 @@
 Copyright (c) 2020 Sébastien Gouëzel. All rights reserved.
 Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
-
-! This file was ported from Lean 3 source module data.real.conjugate_exponents
-! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
-! Please do not edit these lines, except to modify the commit id
-! if you have ported upstream changes.
 -/
 import Mathlib.Data.Real.ENNReal
 
+#align_import data.real.conjugate_exponents from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
+
 /-!
 # Real conjugate exponents

2196ab36

chore: tidy various files (#3584)

3a1848ee

Diff

@@ -101,15 +101,15 @@ theorem div_conj_eq_sub_one : p / q = p - 1 := by
   rw [h.sub_one_mul_conj]
 #align real.is_conjugate_exponent.div_conj_eq_sub_one Real.IsConjugateExponent.div_conj_eq_sub_one
 
-theorem one_lt_nNReal : 1 < Real.toNNReal p := by
+theorem one_lt_nnreal : 1 < Real.toNNReal p := by
   rw [← Real.toNNReal_one, Real.toNNReal_lt_toNNReal_iff h.pos]
   exact h.one_lt
-#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nNReal
+#align real.is_conjugate_exponent.one_lt_nnreal Real.IsConjugateExponent.one_lt_nnreal
 
-theorem inv_add_inv_conj_nNReal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
+theorem inv_add_inv_conj_nnreal : 1 / Real.toNNReal p + 1 / Real.toNNReal q = 1 := by
   rw [← Real.toNNReal_one, ← Real.toNNReal_div' h.nonneg, ← Real.toNNReal_div' h.symm.nonneg,
       ← Real.toNNReal_add h.one_div_nonneg h.symm.one_div_nonneg, h.inv_add_inv_conj]
-#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nNReal
+#align real.is_conjugate_exponent.inv_add_inv_conj_nnreal Real.IsConjugateExponent.inv_add_inv_conj_nnreal
 
 theorem inv_add_inv_conj_ennreal : 1 / ENNReal.ofReal p + 1 / ENNReal.ofReal q = 1 := by
   rw [← ENNReal.ofReal_one, ← ENNReal.ofReal_div_of_pos h.pos,

2196ab36

chore: forward-port leanprover-community/mathlib#17483 (#2884)

This forward ports the changes introduced by leanprover-community/mathlib#17483

No change is needed to Mathlib.Data.EReal as the proofs have been golfed in a different way.

Co-authored-by: Eric Wieser <wieser.eric@gmail.com>

42673620

Diff

@@ -4,7 +4,7 @@ Released under Apache 2.0 license as described in the file LICENSE.
 Authors: Sébastien Gouëzel, Yury Kudryashov
 
 ! This file was ported from Lean 3 source module data.real.conjugate_exponents
-! leanprover-community/mathlib commit bd9851ca476957ea4549eb19b40e7b5ade9428cc
+! leanprover-community/mathlib commit 2196ab363eb097c008d4497125e0dde23fb36db2
 ! Please do not edit these lines, except to modify the commit id
 ! if you have ported upstream changes.
 -/
@@ -73,8 +73,8 @@ theorem one_div_ne_zero : 1 / p ≠ 0 := ne_of_gt h.one_div_pos
 
 theorem conj_eq : q = p / (p - 1) := by
   have := h.inv_add_inv_conj
-  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_inv_eq] at this
-  field_simp [← this, h.ne_zero]
+  rw [← eq_sub_iff_add_eq', one_div, inv_eq_iff_eq_inv] at this
+  field_simp [this, h.ne_zero]
 #align real.is_conjugate_exponent.conj_eq Real.IsConjugateExponent.conj_eq
 
 theorem conjugate_eq : conjugateExponent p = q := h.conj_eq.symm
@@ -134,4 +134,3 @@ theorem isConjugateExponent_one_div {a b : ℝ} (ha : 0 < a) (hb : 0 < b) (hab :
 #align real.is_conjugate_exponent_one_div Real.isConjugateExponent_one_div
 
 end Real
-

bd9851ca

feat: Port Data.Real.ConjugateExponents (#2411)

Rename and reflow only.

a8d52095

`data.real.conjugate_exponents` ⟷ `Mathlib.Data.Real.ConjExponents`

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 373

data.real.conjugate_exponents ⟷ Mathlib.Data.Real.ConjExponents

Changes since the initial port

Changes in mathlib3

Changes in mathlib3port

Changes in mathlib4

Dependencies 9 + 373

`data.real.conjugate_exponents` ⟷ `Mathlib.Data.Real.ConjExponents`