Context stringlengths 57 6.04k | file_name stringlengths 21 79 | start int64 14 1.49k | end int64 18 1.5k | theorem stringlengths 25 1.55k | proof stringlengths 5 7.36k | goals listlengths 0 224 | goals_before listlengths 0 221 |
|---|---|---|---|---|---|---|---|
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Group.Pi.Basic
import Mathlib.Order.Fin
import Mathlib.Order.PiLex
import Mathlib.Order.Interval.Set.Basic
#align_import data.fin.tuple.basic from "leanprover-community/mathlib"@"ef997baa41b5c428be3fb50089a7139bf4ee886b"
assert_not_exists MonoidWithZero
un... | Mathlib/Data/Fin/Tuple/Basic.lean | 128 | 136 | theorem update_cons_zero : update (cons x p) 0 z = cons z p := by |
ext j
by_cases h : j = 0
· rw [h]
simp
· simp only [h, update_noteq, Ne, not_false_iff]
let j' := pred j h
have : j'.succ = j := succ_pred j h
rw [← this, cons_succ, cons_succ]
| [
" Unique ((i : Fin 0) → α i)",
" tail (cons x p) = p",
" cons x p i.succ = p i",
" cons x p 0 = x",
" cons x p 1 = p 0",
" cons x p 1 = cons x p (succ 0)",
" cons x (update p i y) = update (cons x p) i.succ y",
" cons x (update p i y) j = update (cons x p) i.succ y j",
" cons x (update p i y) 0 = up... | [
" Unique ((i : Fin 0) → α i)",
" tail (cons x p) = p",
" cons x p i.succ = p i",
" cons x p 0 = x",
" cons x p 1 = p 0",
" cons x p 1 = cons x p (succ 0)",
" cons x (update p i y) = update (cons x p) i.succ y",
" cons x (update p i y) j = update (cons x p) i.succ y j",
" cons x (update p i y) 0 = up... |
import Mathlib.Order.Monotone.Odd
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
#align_import analysis.special_functions.trigonometric.deriv from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
noncomputable section
open s... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Deriv.lean | 134 | 138 | theorem hasStrictDerivAt_cosh (x : ℂ) : HasStrictDerivAt cosh (sinh x) x := by |
simp only [sinh, div_eq_mul_inv]
convert ((hasStrictDerivAt_exp x).add (hasStrictDerivAt_id x).neg.cexp).mul_const (2 : ℂ)⁻¹
using 1
rw [id, mul_neg_one, sub_eq_add_neg]
| [
" HasStrictDerivAt sin x.cos x",
" HasStrictDerivAt sin ((cexp (x * I) + cexp (-x * I)) * 2⁻¹) x",
" (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-id x * I) * (-1 * I) - cexp (id x * I) * (1 * I)) * I * 2⁻¹",
" (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-x * I) * (-1 * I) - cexp (x * I) * (1 * I)) * I * 2... | [
" HasStrictDerivAt sin x.cos x",
" HasStrictDerivAt sin ((cexp (x * I) + cexp (-x * I)) * 2⁻¹) x",
" (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-id x * I) * (-1 * I) - cexp (id x * I) * (1 * I)) * I * 2⁻¹",
" (cexp (x * I) + cexp (-x * I)) * 2⁻¹ = (cexp (-x * I) * (-1 * I) - cexp (x * I) * (1 * I)) * I * 2... |
import Aesop
import Mathlib.Algebra.Group.Defs
import Mathlib.Data.Nat.Defs
import Mathlib.Data.Int.Defs
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Cases
import Mathlib.Tactic.SimpRw
import Mathlib.Tactic.SplitIfs
#align_import algebra.group.basic from "leanprover-community/mathlib"@"a07d750983b94c530a... | Mathlib/Algebra/Group/Basic.lean | 117 | 119 | theorem comp_mul_left (x y : α) : (x * ·) ∘ (y * ·) = (x * y * ·) := by |
ext z
simp [mul_assoc]
| [
" ((fun x_1 => x * x_1) ∘ fun x => y * x) = fun x_1 => x * y * x_1",
" ((fun x_1 => x * x_1) ∘ fun x => y * x) z = x * y * z"
] | [
" ((fun x_1 => x * x_1) ∘ fun x => y * x) = fun x_1 => x * y * x_1"
] |
import Mathlib.Data.Opposite
import Mathlib.Data.Set.Defs
#align_import data.set.opposite from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
variable {α : Type*}
open Opposite
namespace Set
protected def op (s : Set α) : Set αᵒᵖ :=
unop ⁻¹' s
#align set.op Set.op
protected def u... | Mathlib/Data/Set/Opposite.lean | 100 | 104 | theorem singleton_unop_op (x : αᵒᵖ) : ({unop x} : Set α).op = {x} := by |
ext
constructor
· apply unop_injective
· apply op_injective
| [
" { unop := a } ∈ s.op ↔ a ∈ s",
" a.unop ∈ s.unop ↔ a ∈ s",
" {x}.op = {{ unop := x }}",
" x✝ ∈ {x}.op ↔ x✝ ∈ {{ unop := x }}",
" x✝ ∈ {x}.op → x✝ ∈ {{ unop := x }}",
" x✝ ∈ {{ unop := x }} → x✝ ∈ {x}.op",
" {x}.unop = {x.unop}",
" x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}",
" x✝ ∈ {x}.unop → x✝ ∈ {x.unop}",
... | [
" { unop := a } ∈ s.op ↔ a ∈ s",
" a.unop ∈ s.unop ↔ a ∈ s",
" {x}.op = {{ unop := x }}",
" x✝ ∈ {x}.op ↔ x✝ ∈ {{ unop := x }}",
" x✝ ∈ {x}.op → x✝ ∈ {{ unop := x }}",
" x✝ ∈ {{ unop := x }} → x✝ ∈ {x}.op",
" {x}.unop = {x.unop}",
" x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}",
" x✝ ∈ {x}.unop → x✝ ∈ {x.unop}",
... |
import Mathlib.Data.ENNReal.Operations
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal
namespace ENNReal
noncomputable section Inv
variable {a b c d : ℝ≥0∞} {r p q : ℝ≥0}
protected theorem div_eq_inv_mul : a / b = b⁻¹ * a := by rw [... | Mathlib/Data/ENNReal/Inv.lean | 137 | 138 | theorem inv_lt_top {x : ℝ≥0∞} : x⁻¹ < ∞ ↔ 0 < x := by |
simp only [lt_top_iff_ne_top, inv_ne_top, pos_iff_ne_zero]
| [
" a / b = b⁻¹ * a",
" sInf {b | 1 ≤ 0 * b} = ⊤",
" a ∈ {b | 1 ≤ ⊤ * b}",
" ∀ (p : ℝ≥0), b = ↑p → r⁻¹ ≤ p",
" r⁻¹ ≤ b",
" 1 ≤ r * b",
" 1 ≤ ↑r * ↑r⁻¹",
" ↑2⁻¹ = 2⁻¹",
" ↑(p / r) = ↑p / ↑r",
" ↑(p / r) ≤ ↑p / ↑r",
" a / 0 = ⊤",
" 1⁻¹ = 1",
" (x✝ ^ 0)⁻¹ = x✝⁻¹ ^ 0",
" (⊤ ^ (n + 1))⁻¹ = ⊤⁻¹ ^ ... | [
" a / b = b⁻¹ * a",
" sInf {b | 1 ≤ 0 * b} = ⊤",
" a ∈ {b | 1 ≤ ⊤ * b}",
" ∀ (p : ℝ≥0), b = ↑p → r⁻¹ ≤ p",
" r⁻¹ ≤ b",
" 1 ≤ r * b",
" 1 ≤ ↑r * ↑r⁻¹",
" ↑2⁻¹ = 2⁻¹",
" ↑(p / r) = ↑p / ↑r",
" ↑(p / r) ≤ ↑p / ↑r",
" a / 0 = ⊤",
" 1⁻¹ = 1",
" (x✝ ^ 0)⁻¹ = x✝⁻¹ ^ 0",
" (⊤ ^ (n + 1))⁻¹ = ⊤⁻¹ ^ ... |
import Mathlib.Probability.Notation
import Mathlib.Probability.Integration
import Mathlib.MeasureTheory.Function.L2Space
#align_import probability.variance from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open MeasureTheory Filter Finset
noncomputable section
open scoped MeasureThe... | Mathlib/Probability/Variance.lean | 106 | 113 | theorem evariance_eq_lintegral_ofReal (X : Ω → ℝ) (μ : Measure Ω) :
evariance X μ = ∫⁻ ω, ENNReal.ofReal ((X ω - μ[X]) ^ 2) ∂μ := by |
rw [evariance]
congr
ext1 ω
rw [pow_two, ← ENNReal.coe_mul, ← nnnorm_mul, ← pow_two]
congr
exact (Real.toNNReal_eq_nnnorm_of_nonneg <| sq_nonneg _).symm
| [
" evariance X μ < ⊤",
" evariance X μ = ⊤",
" False",
" Memℒp (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ",
" snorm (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2) < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ... | [
" evariance X μ < ⊤",
" evariance X μ = ⊤",
" False",
" Memℒp (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ",
" snorm (fun ω => X ω - ∫ (x : Ω), X x ∂μ) 2 μ < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ ENNReal.toReal 2 ∂μ) ^ (1 / ENNReal.toReal 2) < ⊤",
" (∫⁻ (x : Ω), ↑‖X x - ∫ (x : Ω), X x ∂μ‖₊ ^ 2 ∂μ) ... |
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.Algebra.Order.Group.OrderIso
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Order.UpperLower.Basic
#align_import algebra.order.upper_lower from "leanprover-community/mathlib"@"c0c52abb75074ed8b73a948341f50521fbf43b4c"
open Function Set
open Pointw... | Mathlib/Algebra/Order/UpperLower.lean | 56 | 58 | theorem Set.OrdConnected.smul (hs : s.OrdConnected) : (a • s).OrdConnected := by |
rw [← hs.upperClosure_inter_lowerClosure, smul_set_inter]
exact (upperClosure _).upper.smul.ordConnected.inter (lowerClosure _).lower.smul.ordConnected
| [
" (a • s).OrdConnected",
" (a • ↑(upperClosure s) ∩ a • ↑(lowerClosure s)).OrdConnected"
] | [
" (a • s).OrdConnected"
] |
import Mathlib.Analysis.SpecialFunctions.Complex.Log
#align_import analysis.special_functions.pow.complex from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
open scoped Classical
open Real Topology Filter ComplexConjugate Finset Set
namespace Complex
noncomputable def cpow (x y : ℂ) ... | Mathlib/Analysis/SpecialFunctions/Pow/Complex.lean | 55 | 55 | theorem zero_cpow {x : ℂ} (h : x ≠ 0) : (0 : ℂ) ^ x = 0 := by | simp [cpow_def, *]
| [
" x ^ 0 = 1",
" x ^ y = 0 ↔ x = 0 ∧ y ≠ 0",
" (if x = 0 then if y = 0 then 1 else 0 else cexp (x.log * y)) = 0 ↔ x = 0 ∧ y ≠ 0",
" 1 = 0 ↔ x = 0 ∧ y ≠ 0",
" 0 = 0 ↔ x = 0 ∧ y ≠ 0",
" cexp (x.log * y) = 0 ↔ x = 0 ∧ y ≠ 0",
" 0 ^ x = 0"
] | [
" x ^ 0 = 1",
" x ^ y = 0 ↔ x = 0 ∧ y ≠ 0",
" (if x = 0 then if y = 0 then 1 else 0 else cexp (x.log * y)) = 0 ↔ x = 0 ∧ y ≠ 0",
" 1 = 0 ↔ x = 0 ∧ y ≠ 0",
" 0 = 0 ↔ x = 0 ∧ y ≠ 0",
" cexp (x.log * y) = 0 ↔ x = 0 ∧ y ≠ 0",
" 0 ^ x = 0"
] |
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Data.Nat.Cast.Order
import Mathlib.Tactic.Common
#align_import data.nat.cast.field from "leanprover-community/mathlib"@"acee671f47b8e7972a1eb6f4eed74b4b3abce829"
namespace Nat
variable {α : Type*}
@[simp]
theorem cast_div [DivisionSemiring α] {m n : ℕ} (n_... | Mathlib/Data/Nat/Cast/Field.lean | 76 | 79 | theorem one_div_lt_one_div {n m : ℕ} (h : n < m) : 1 / ((m : α) + 1) < 1 / ((n : α) + 1) := by |
refine one_div_lt_one_div_of_lt ?_ ?_
· exact Nat.cast_add_one_pos _
· simpa
| [
" ↑(m / n) = ↑m / ↑n",
" ↑(n * k / n) = ↑(n * k) / ↑n",
" n ≠ 0",
" False",
" ↑(m / d) / ↑(n / d) = ↑m / ↑n",
" ↑(m / 0) / ↑(n / 0) = ↑m / ↑n",
" ↑d ≠ 0",
" (↑0)⁻¹ ≤ 1",
" 1 ≤ ↑(n + 1)",
" ↑(m / n) ≤ ↑m / ↑n",
" ↑(m / 0) ≤ ↑m / ↑0",
" ↑(m / (n✝ + 1)) ≤ ↑m / ↑(n✝ + 1)",
" m / (n✝ + 1) * (n✝ +... | [
" ↑(m / n) = ↑m / ↑n",
" ↑(n * k / n) = ↑(n * k) / ↑n",
" n ≠ 0",
" False",
" ↑(m / d) / ↑(n / d) = ↑m / ↑n",
" ↑(m / 0) / ↑(n / 0) = ↑m / ↑n",
" ↑d ≠ 0",
" (↑0)⁻¹ ≤ 1",
" 1 ≤ ↑(n + 1)",
" ↑(m / n) ≤ ↑m / ↑n",
" ↑(m / 0) ≤ ↑m / ↑0",
" ↑(m / (n✝ + 1)) ≤ ↑m / ↑(n✝ + 1)",
" m / (n✝ + 1) * (n✝ +... |
import Mathlib.Algebra.Lie.Abelian
import Mathlib.Algebra.Lie.IdealOperations
import Mathlib.Algebra.Lie.Quotient
#align_import algebra.lie.normalizer from "leanprover-community/mathlib"@"938fead7abdc0cbbca8eba7a1052865a169dc102"
variable {R L M M' : Type*}
variable [CommRing R] [LieRing L] [LieAlgebra R L]
varia... | Mathlib/Algebra/Lie/Normalizer.lean | 82 | 83 | theorem comap_normalizer (f : M' →ₗ⁅R,L⁆ M) : N.normalizer.comap f = (N.comap f).normalizer := by |
ext; simp
| [
" ⁅x, a✝ + b✝⁆ ∈ N",
" ⁅x, a✝⁆ + ⁅x, b✝⁆ ∈ N",
" ⁅x, 0⁆ ∈ N",
" ⁅x, t • m⁆ ∈ N",
" t • ⁅x, m⁆ ∈ N",
" ⁅y, ⁅x, m⁆⁆ ∈ N",
" ⁅⁅y, x⁆, m⁆ + ⁅x, ⁅y, m⁆⁆ ∈ N",
" N ≤ N.normalizer",
" m ∈ N.normalizer",
" ∀ (x : L), ⁅x, m⁆ ∈ N",
" (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer",
" m✝ ∈ (N₁ ⊓ N₂... | [
" ⁅x, a✝ + b✝⁆ ∈ N",
" ⁅x, a✝⁆ + ⁅x, b✝⁆ ∈ N",
" ⁅x, 0⁆ ∈ N",
" ⁅x, t • m⁆ ∈ N",
" t • ⁅x, m⁆ ∈ N",
" ⁅y, ⁅x, m⁆⁆ ∈ N",
" ⁅⁅y, x⁆, m⁆ + ⁅x, ⁅y, m⁆⁆ ∈ N",
" N ≤ N.normalizer",
" m ∈ N.normalizer",
" ∀ (x : L), ⁅x, m⁆ ∈ N",
" (N₁ ⊓ N₂).normalizer = N₁.normalizer ⊓ N₂.normalizer",
" m✝ ∈ (N₁ ⊓ N₂... |
import Mathlib.Analysis.SpecialFunctions.Exp
import Mathlib.Data.Nat.Factorization.Basic
import Mathlib.Analysis.NormedSpace.Real
#align_import analysis.special_functions.log.basic from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable ... | Mathlib/Analysis/SpecialFunctions/Log/Basic.lean | 64 | 66 | theorem exp_log_of_neg (hx : x < 0) : exp (log x) = -x := by |
rw [exp_log_eq_abs (ne_of_lt hx)]
exact abs_of_neg hx
| [
" x.log = expOrderIso.symm ⟨x, hx⟩",
" expOrderIso.symm ⟨|x|, ⋯⟩ = expOrderIso.symm ⟨x, hx⟩",
" |x| = x",
" rexp x.log = |x|",
" rexp x.log = x",
" rexp x.log = -x",
" |x| = -x"
] | [
" x.log = expOrderIso.symm ⟨x, hx⟩",
" expOrderIso.symm ⟨|x|, ⋯⟩ = expOrderIso.symm ⟨x, hx⟩",
" |x| = x",
" rexp x.log = |x|",
" rexp x.log = x",
" rexp x.log = -x"
] |
import Mathlib.Data.Real.Irrational
import Mathlib.Data.Nat.Fib.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Algebra.LinearRecurrence
import Mathlib.Tactic.NormNum.NatFib
import Mathlib.Tactic.NormNum.Prime
#align_import data.real.golden_ratio from "leanprover-community/mathlib"@"2196ab363eb097c008d449712... | Mathlib/Data/Real/GoldenRatio.lean | 98 | 101 | theorem goldConj_sq : ψ ^ 2 = ψ + 1 := by |
rw [goldenConj, ← sub_eq_zero]
ring_nf
rw [Real.sq_sqrt] <;> norm_num
| [
" φ⁻¹ = -ψ",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" ψ⁻¹ = -φ",
" -ψ = φ⁻¹",
" φ * ψ = -1",
" (1 + √5) * (1 - √5) = -(2 * 2)",
" 1 ^ 2 - √5 ^ 2 = -(2 * 2)",
" ψ * φ = -1",
" φ + ψ = 1",
" (1 + √5) / 2 + (1 - √5) / 2 = 1",
" 1 - φ = ψ",
" 1 - ψ = φ",
" φ - ψ = √5",
" φ ^ (n + 2) - φ ^ (... | [
" φ⁻¹ = -ψ",
" 0 < 1",
" 0 < 5",
" 2 * 2 = 5 - 1",
" ψ⁻¹ = -φ",
" -ψ = φ⁻¹",
" φ * ψ = -1",
" (1 + √5) * (1 - √5) = -(2 * 2)",
" 1 ^ 2 - √5 ^ 2 = -(2 * 2)",
" ψ * φ = -1",
" φ + ψ = 1",
" (1 + √5) / 2 + (1 - √5) / 2 = 1",
" 1 - φ = ψ",
" 1 - ψ = φ",
" φ - ψ = √5",
" φ ^ (n + 2) - φ ^ (... |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.FieldTheory.Minpoly.IsIntegrallyClosed
import Mathlib.RingTheory.PowerBasis
#align_import ring_theory.is_adjoin_root from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
open scoped Polynomial
open Polynomial
noncomputable sec... | Mathlib/RingTheory/IsAdjoinRoot.lean | 186 | 188 | theorem ext_map (h h' : IsAdjoinRoot S f) (eq : ∀ x, h.map x = h'.map x) : h = h' := by |
cases h; cases h'; congr
exact RingHom.ext eq
| [
" (algebraMap R S) x = h.map (C x)",
" p ∈ RingHom.ker h.map ↔ f ∣ p",
" h.map p = 0 ↔ f ∣ p",
" (aeval h.root) (C x) = h.map (C x)",
" (aeval h.root) (p + q) = h.map (p + q)",
" (aeval h.root) (C x * X ^ (n + 1)) = h.map (C x * X ^ (n + 1))",
" (aeval h.root) f = 0",
" h.repr 0 ∈ Ideal.span {f}",
"... | [
" (algebraMap R S) x = h.map (C x)",
" p ∈ RingHom.ker h.map ↔ f ∣ p",
" h.map p = 0 ↔ f ∣ p",
" (aeval h.root) (C x) = h.map (C x)",
" (aeval h.root) (p + q) = h.map (p + q)",
" (aeval h.root) (C x * X ^ (n + 1)) = h.map (C x * X ^ (n + 1))",
" (aeval h.root) f = 0",
" h.repr 0 ∈ Ideal.span {f}",
"... |
import Mathlib.Geometry.Manifold.Diffeomorph
import Mathlib.Geometry.Manifold.Instances.Real
import Mathlib.Geometry.Manifold.PartitionOfUnity
#align_import geometry.manifold.whitney_embedding from "leanprover-community/mathlib"@"86c29aefdba50b3f33e86e52e3b2f51a0d8f0282"
universe uι uE uH uM
variable {ι : Type u... | Mathlib/Geometry/Manifold/WhitneyEmbedding.lean | 68 | 75 | theorem embeddingPiTangent_injOn : InjOn f.embeddingPiTangent s := by |
intro x hx y _ h
simp only [embeddingPiTangent_coe, funext_iff] at h
obtain ⟨h₁, h₂⟩ := Prod.mk.inj_iff.1 (h (f.ind x hx))
rw [f.apply_ind x hx] at h₂
rw [← h₂, f.apply_ind x hx, one_smul, one_smul] at h₁
have := f.mem_extChartAt_source_of_eq_one h₂.symm
exact (extChartAt I (f.c _)).injOn (f.mem_extChart... | [
" InjOn (⇑f.embeddingPiTangent) s",
" x = y"
] | [
" InjOn (⇑f.embeddingPiTangent) s"
] |
import Mathlib.Algebra.Module.Zlattice.Basic
import Mathlib.NumberTheory.NumberField.Embeddings
import Mathlib.NumberTheory.NumberField.FractionalIdeal
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
variable (K : Type*) [F... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/Basic.lean | 296 | 300 | theorem normAtPlace_apply (w : InfinitePlace K) (x : K) :
normAtPlace w (mixedEmbedding K x) = w x := by |
simp_rw [normAtPlace, MonoidWithZeroHom.coe_mk, ZeroHom.coe_mk, mixedEmbedding,
RingHom.prod_apply, Pi.ringHom_apply, norm_embedding_of_isReal, norm_embedding_eq, dite_eq_ite,
ite_id]
| [
" Nontrivial (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))",
" finrank ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) = finrank ℚ K",
" Function.Injective ⇑(mixedEmbedding K)",
" (fun x => if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖) 0 = 0",
" { toFun := fun x => if hw : w.IsRea... | [
" Nontrivial (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ))",
" finrank ℝ (({ w // w.IsReal } → ℝ) × ({ w // w.IsComplex } → ℂ)) = finrank ℚ K",
" Function.Injective ⇑(mixedEmbedding K)",
" (fun x => if hw : w.IsReal then ‖x.1 ⟨w, hw⟩‖ else ‖x.2 ⟨w, ⋯⟩‖) 0 = 0",
" { toFun := fun x => if hw : w.IsRea... |
import Mathlib.RingTheory.Polynomial.Basic
import Mathlib.RingTheory.Ideal.LocalRing
#align_import data.polynomial.expand from "leanprover-community/mathlib"@"bbeb185db4ccee8ed07dc48449414ebfa39cb821"
universe u v w
open Polynomial
open Finset
namespace Polynomial
section CommSemiring
variable (R : Type u) [... | Mathlib/Algebra/Polynomial/Expand.lean | 65 | 66 | theorem expand_monomial (r : R) : expand R p (monomial q r) = monomial (q * p) r := by |
simp_rw [← smul_X_eq_monomial, AlgHom.map_smul, AlgHom.map_pow, expand_X, mul_comm, pow_mul]
| [
" (expand R p) f = f.sum fun e a => C a * (X ^ p) ^ e",
" (expand R p) ((monomial q) r) = (monomial (q * p)) r"
] | [
" (expand R p) f = f.sum fun e a => C a * (X ^ p) ^ e",
" (expand R p) ((monomial q) r) = (monomial (q * p)) r"
] |
import Mathlib.Data.Finset.Lattice
#align_import combinatorics.set_family.compression.down from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
variable {α : Type*} [DecidableEq α] {𝒜 ℬ : Finset (Finset α)} {s : Finset α} {a : α}
namespace Finset
def nonMemberSubfamily (a : α) (𝒜 : ... | Mathlib/Combinatorics/SetFamily/Compression/Down.lean | 56 | 57 | theorem mem_nonMemberSubfamily : s ∈ 𝒜.nonMemberSubfamily a ↔ s ∈ 𝒜 ∧ a ∉ s := by |
simp [nonMemberSubfamily]
| [
" s ∈ nonMemberSubfamily a 𝒜 ↔ s ∈ 𝒜 ∧ a ∉ s"
] | [
" s ∈ nonMemberSubfamily a 𝒜 ↔ s ∈ 𝒜 ∧ a ∉ s"
] |
import Mathlib.Algebra.GroupWithZero.Hom
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.Algebra.Order.GroupWithZero.Canonical
import Mathlib.Order.Hom.Basic
#align_import algebra.order.hom.monoid from "leanprover-community/mathlib"@"3342d1b2178381196f818146ff79bc0e7ccd9e2d"
open Function
variable {F... | Mathlib/Algebra/Order/Hom/Monoid.lean | 216 | 221 | theorem strictMono_iff_map_pos : StrictMono (f : α → β) ↔ ∀ a, 0 < a → 0 < f a := by |
refine ⟨fun h a => ?_, fun h a b hl => ?_⟩
· rw [← map_zero f]
apply h
· rw [← sub_add_cancel b a, map_add f]
exact lt_add_of_pos_left _ (h _ <| sub_pos.2 hl)
| [
" 0 ≤ a → 0 ≤ f a",
" 0 ≤ a → f 0 ≤ f a",
" f a ≤ f b",
" f a ≤ f (b - a) + f a",
" StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a",
" 0 < a → 0 < f a",
" 0 < a → f 0 < f a",
" f a < f b",
" f a < f (b - a) + f a"
] | [
" 0 ≤ a → 0 ≤ f a",
" 0 ≤ a → f 0 ≤ f a",
" f a ≤ f b",
" f a ≤ f (b - a) + f a",
" StrictMono ⇑f ↔ ∀ (a : α), 0 < a → 0 < f a"
] |
import Mathlib.Analysis.RCLike.Lemmas
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Inner
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.function.l2_space from "leanprover-community/mathlib"@"83a66c8775fa14ee5180c85cab98e970956401ad"
set_option linter.uppercaseLean3 false... | Mathlib/MeasureTheory/Function/L2Space.lean | 54 | 57 | theorem memℒp_two_iff_integrable_sq {f : α → ℝ} (hf : AEStronglyMeasurable f μ) :
Memℒp f 2 μ ↔ Integrable (fun x => f x ^ 2) μ := by |
convert memℒp_two_iff_integrable_sq_norm hf using 3
simp
| [
" Integrable (fun x => f x ^ 2) μ",
" Memℒp f 2 μ ↔ Integrable (fun x => ‖f x‖ ^ 2) μ",
" Memℒp f 2 μ ↔ Memℒp (fun x => ‖f x‖ ^ 2) 1 μ",
" ‖f x✝‖ ^ 2 = ‖f x✝‖ ^ ENNReal.toReal 2",
" 1 = 2 / 2",
" Memℒp f 2 μ ↔ Integrable (fun x => f x ^ 2) μ",
" f x✝ ^ 2 = ‖f x✝‖ ^ 2"
] | [
" Integrable (fun x => f x ^ 2) μ",
" Memℒp f 2 μ ↔ Integrable (fun x => ‖f x‖ ^ 2) μ",
" Memℒp f 2 μ ↔ Memℒp (fun x => ‖f x‖ ^ 2) 1 μ",
" ‖f x✝‖ ^ 2 = ‖f x✝‖ ^ ENNReal.toReal 2",
" 1 = 2 / 2",
" Memℒp f 2 μ ↔ Integrable (fun x => f x ^ 2) μ"
] |
import Mathlib.SetTheory.Game.State
#align_import set_theory.game.domineering from "leanprover-community/mathlib"@"b134b2f5cf6dd25d4bbfd3c498b6e36c11a17225"
namespace SetTheory
namespace PGame
namespace Domineering
open Function
@[simps!]
def shiftUp : ℤ × ℤ ≃ ℤ × ℤ :=
(Equiv.refl ℤ).prodCongr (Equiv.addRig... | Mathlib/SetTheory/Game/Domineering.lean | 125 | 126 | theorem moveLeft_smaller {b : Board} {m : ℤ × ℤ} (h : m ∈ left b) :
Finset.card (moveLeft b m) / 2 < Finset.card b / 2 := by | simp [← moveLeft_card h, lt_add_one]
| [
" (m.1 - 1, m.2) ∈ Finset.erase b m",
" (m.1 - 1, m.2) ≠ m",
" (m.1, m.2 - 1) ∈ Finset.erase b m",
" (m.1, m.2 - 1) ≠ m",
" 2 ≤ Finset.card b",
" Finset.card (moveLeft b m) + 2 = Finset.card b",
" ((Finset.erase b m).erase (m.1, m.2 - 1)).card + 2 = Finset.card b",
" (Finset.erase b m).card - 1 + 2 = ... | [
" (m.1 - 1, m.2) ∈ Finset.erase b m",
" (m.1 - 1, m.2) ≠ m",
" (m.1, m.2 - 1) ∈ Finset.erase b m",
" (m.1, m.2 - 1) ≠ m",
" 2 ≤ Finset.card b",
" Finset.card (moveLeft b m) + 2 = Finset.card b",
" ((Finset.erase b m).erase (m.1, m.2 - 1)).card + 2 = Finset.card b",
" (Finset.erase b m).card - 1 + 2 = ... |
import Mathlib.ModelTheory.Syntax
import Mathlib.ModelTheory.Semantics
import Mathlib.Algebra.Ring.Equiv
variable {α : Type*}
namespace FirstOrder
open FirstOrder
inductive ringFunc : ℕ → Type
| add : ringFunc 2
| mul : ringFunc 2
| neg : ringFunc 1
| zero : ringFunc 0
| one : ringFunc 0
deriving D... | Mathlib/ModelTheory/Algebra/Ring/Basic.lean | 180 | 182 | theorem realize_add (x y : ring.Term α) (v : α → R) :
Term.realize v (x + y) = Term.realize v x + Term.realize v y := by |
simp [add_def, funMap_add]
| [
" DecidableEq (ring.Functions n)",
" DecidableEq (ringFunc n)",
" DecidableEq (ring.Relations n)",
" DecidableEq Empty",
" (↑[Sum.inl ⟨2, add⟩, Sum.inl ⟨2, mul⟩, Sum.inl ⟨1, neg⟩, Sum.inl ⟨0, zero⟩, Sum.inl ⟨0, one⟩]).Nodup",
" ∀ (x : ring.Symbols),\n x ∈\n { val := ↑[Sum.inl ⟨2, add⟩, Sum.inl ⟨2,... | [
" DecidableEq (ring.Functions n)",
" DecidableEq (ringFunc n)",
" DecidableEq (ring.Relations n)",
" DecidableEq Empty",
" (↑[Sum.inl ⟨2, add⟩, Sum.inl ⟨2, mul⟩, Sum.inl ⟨1, neg⟩, Sum.inl ⟨0, zero⟩, Sum.inl ⟨0, one⟩]).Nodup",
" ∀ (x : ring.Symbols),\n x ∈\n { val := ↑[Sum.inl ⟨2, add⟩, Sum.inl ⟨2,... |
import Mathlib.Algebra.Order.Monoid.Defs
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
open Function
universe u
variable {α : Type u}
class OrderedAddCommGroup (α : Ty... | Mathlib/Algebra/Order/Group/Defs.lean | 196 | 197 | theorem lt_inv_mul_iff_lt : 1 < b⁻¹ * a ↔ b < a := by |
rw [← mul_lt_mul_iff_left b, mul_one, mul_inv_cancel_left]
| [
" b ≤ c",
" 1 < a⁻¹ ↔ a < 1",
" a⁻¹ < 1 ↔ 1 < a",
" b < a⁻¹ * c ↔ a * b < c",
" a * b < a * (a⁻¹ * c) ↔ a * b < c",
" b⁻¹ * a < c ↔ a < b * c",
" a * a⁻¹ < a * b ↔ 1 < a * b",
" b * a < b * b⁻¹ ↔ b * a < 1",
" 1 < b⁻¹ * a ↔ b < a"
] | [
" b ≤ c",
" 1 < a⁻¹ ↔ a < 1",
" a⁻¹ < 1 ↔ 1 < a",
" b < a⁻¹ * c ↔ a * b < c",
" a * b < a * (a⁻¹ * c) ↔ a * b < c",
" b⁻¹ * a < c ↔ a < b * c",
" a * a⁻¹ < a * b ↔ 1 < a * b",
" b * a < b * b⁻¹ ↔ b * a < 1",
" 1 < b⁻¹ * a ↔ b < a"
] |
import Mathlib.Data.Finset.Basic
import Mathlib.ModelTheory.Syntax
import Mathlib.Data.List.ProdSigma
#align_import model_theory.semantics from "leanprover-community/mathlib"@"d565b3df44619c1498326936be16f1a935df0728"
universe u v w u' v'
namespace FirstOrder
namespace Language
variable {L : Language.{u, v}} {... | Mathlib/ModelTheory/Semantics.lean | 109 | 113 | theorem realize_functions_apply₁ {f : L.Functions 1} {t : L.Term α} {v : α → M} :
(f.apply₁ t).realize v = funMap f ![t.realize v] := by |
rw [Functions.apply₁, Term.realize]
refine congr rfl (funext fun i => ?_)
simp only [Matrix.cons_val_fin_one]
| [
" realize v (relabel g t) = realize (v ∘ g) t",
" realize v (relabel g (var a✝)) = realize (v ∘ g) (var a✝)",
" realize v (relabel g (func f ts)) = realize (v ∘ g) (func f ts)",
" realize v (f.apply₁ t) = funMap f ![realize v t]",
" (funMap f fun i => realize v (![t] i)) = funMap f ![realize v t]",
" real... | [
" realize v (relabel g t) = realize (v ∘ g) t",
" realize v (relabel g (var a✝)) = realize (v ∘ g) (var a✝)",
" realize v (relabel g (func f ts)) = realize (v ∘ g) (func f ts)",
" realize v (f.apply₁ t) = funMap f ![realize v t]"
] |
import Mathlib.Topology.Order.IsLUB
open Set Filter TopologicalSpace Topology Function
open OrderDual (toDual ofDual)
variable {α β γ : Type*}
section ConditionallyCompleteLinearOrder
variable [ConditionallyCompleteLinearOrder α] [TopologicalSpace α] [OrderTopology α]
[ConditionallyCompleteLinearOrder β] [Top... | Mathlib/Topology/Order/Monotone.lean | 75 | 79 | theorem Antitone.map_iInf_of_continuousAt' {ι : Sort*} [Nonempty ι] {f : α → β} {g : ι → α}
(Cf : ContinuousAt f (iInf g)) (Af : Antitone f)
(bdd : BddBelow (range g) := by | bddDefault) : f (⨅ i, g i) = ⨆ i, f (g i) := by
rw [iInf, Antitone.map_sInf_of_continuousAt' Cf Af (range_nonempty g) bdd, ← range_comp, iSup]
rfl
| [
" f (⨆ i, g i) = ⨆ i, f (g i)",
" sSup (range (f ∘ g)) = sSup (range fun i => f (g i))",
" f (⨅ i, g i) = ⨅ i, f (g i)",
" sInf (range (f ∘ g)) = sInf (range fun i => f (g i))",
" f (⨅ i, g i) = ⨆ i, f (g i)"
] | [
" f (⨆ i, g i) = ⨆ i, f (g i)",
" sSup (range (f ∘ g)) = sSup (range fun i => f (g i))",
" f (⨅ i, g i) = ⨅ i, f (g i)",
" sInf (range (f ∘ g)) = sInf (range fun i => f (g i))"
] |
import Mathlib.Data.Multiset.FinsetOps
import Mathlib.Data.Multiset.Fold
#align_import data.multiset.lattice from "leanprover-community/mathlib"@"65a1391a0106c9204fe45bc73a039f056558cb83"
namespace Multiset
variable {α : Type*}
section Inf
-- can be defined with just `[Top α]` where some lemmas hold with... | Mathlib/Data/Multiset/Lattice.lean | 173 | 174 | theorem inf_ndinsert (a : α) (s : Multiset α) : (ndinsert a s).inf = a ⊓ s.inf := by |
rw [← inf_dedup, dedup_ext.2, inf_dedup, inf_cons]; simp
| [
" (s₁ + s₂).inf = fold (fun x x_1 => x ⊓ x_1) (⊤ ⊓ ⊤) (s₁ + s₂)",
" a ≤ inf 0 ↔ ∀ b ∈ 0, a ≤ b",
" ∀ (a_1 : α) (s : Multiset α), (a ≤ s.inf ↔ ∀ b ∈ s, a ≤ b) → (a ≤ (a_1 ::ₘ s).inf ↔ ∀ b ∈ a_1 ::ₘ s, a ≤ b)",
" (s₁.ndunion s₂).inf = s₁.inf ⊓ s₂.inf",
" ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂",
" (s₁ ∪ ... | [
" (s₁ + s₂).inf = fold (fun x x_1 => x ⊓ x_1) (⊤ ⊓ ⊤) (s₁ + s₂)",
" a ≤ inf 0 ↔ ∀ b ∈ 0, a ≤ b",
" ∀ (a_1 : α) (s : Multiset α), (a ≤ s.inf ↔ ∀ b ∈ s, a ≤ b) → (a ≤ (a_1 ::ₘ s).inf ↔ ∀ b ∈ a_1 ::ₘ s, a ≤ b)",
" (s₁.ndunion s₂).inf = s₁.inf ⊓ s₂.inf",
" ∀ (a : α), a ∈ s₁.ndunion s₂ ↔ a ∈ s₁ + s₂",
" (s₁ ∪ ... |
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.TryThis
import Mathlib.Util.AtomM
set_option autoImplicit true
namespace Mathlib.Tactic.Abel
open Lean Elab Meta Tactic Qq
initialize registerTraceClass `abel
initialize registerTraceClass `abel.detail
structure Context where
α : Expr
univ :... | Mathlib/Tactic/Abel.lean | 154 | 155 | theorem zero_term {α} [AddCommMonoid α] (x a) : @term α _ 0 x a = a := by |
simp [term, zero_nsmul, one_nsmul]
| [
" k + term n x a = term n x a'",
" k + termg n x a = termg n x a'",
" term n x a + k = term n x a'",
" termg n x a + k = termg n x a'",
" term n₁ x a₁ + term n₂ x a₂ = term n' x a'",
" termg n₁ x a₁ + termg n₂ x a₂ = termg n' x a'",
" n₁ • x + a₁ + (n₂ • x + a₂) = n₁ • x + n₂ • x + (a₁ + a₂)",
" term ... | [
" k + term n x a = term n x a'",
" k + termg n x a = termg n x a'",
" term n x a + k = term n x a'",
" termg n x a + k = termg n x a'",
" term n₁ x a₁ + term n₂ x a₂ = term n' x a'",
" termg n₁ x a₁ + termg n₂ x a₂ = termg n' x a'",
" n₁ • x + a₁ + (n₂ • x + a₂) = n₁ • x + n₂ • x + (a₁ + a₂)",
" term ... |
import Mathlib.Algebra.Module.BigOperators
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
import Mathlib.LinearAlgebra.AffineSpace.AffineSubspace
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.Tactic.FinCases
#align_import linear_algebra.affine_space.combination from ... | Mathlib/LinearAlgebra/AffineSpace/Combination.lean | 141 | 145 | theorem weightedVSubOfPoint_erase [DecidableEq ι] (w : ι → k) (p : ι → P) (i : ι) :
(s.erase i).weightedVSubOfPoint p (p i) w = s.weightedVSubOfPoint p (p i) w := by |
rw [weightedVSubOfPoint_apply, weightedVSubOfPoint_apply]
apply sum_erase
rw [vsub_self, smul_zero]
| [
" univ = {0, 1}",
" x ∈ univ ↔ x ∈ {0, 1}",
" ⟨0, ⋯⟩ ∈ univ ↔ ⟨0, ⋯⟩ ∈ {0, 1}",
" ⟨1, ⋯⟩ ∈ univ ↔ ⟨1, ⋯⟩ ∈ {0, 1}",
" (s.weightedVSubOfPoint p b) w = ∑ i ∈ s, w i • (p i -ᵥ b)",
" (s.weightedVSubOfPoint (fun x => p) b) w = (∑ i ∈ s, w i) • (p -ᵥ b)",
" (s.weightedVSubOfPoint p₁ b) w₁ = (s.weightedVSubOf... | [
" univ = {0, 1}",
" x ∈ univ ↔ x ∈ {0, 1}",
" ⟨0, ⋯⟩ ∈ univ ↔ ⟨0, ⋯⟩ ∈ {0, 1}",
" ⟨1, ⋯⟩ ∈ univ ↔ ⟨1, ⋯⟩ ∈ {0, 1}",
" (s.weightedVSubOfPoint p b) w = ∑ i ∈ s, w i • (p i -ᵥ b)",
" (s.weightedVSubOfPoint (fun x => p) b) w = (∑ i ∈ s, w i) • (p -ᵥ b)",
" (s.weightedVSubOfPoint p₁ b) w₁ = (s.weightedVSubOf... |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
#align_import analysis.special_functions.pow.nnreal from "leanprover-community/mathlib"@"4fa54b337f7d52805480306db1b1439c741848c8"
noncomputable section
open scoped Classical
open Real NNReal ENNReal ComplexConjugate
open Finset Function Set
namespace NNReal
var... | Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean | 124 | 127 | theorem sqrt_eq_rpow (x : ℝ≥0) : sqrt x = x ^ (1 / (2 : ℝ)) := by |
refine NNReal.eq ?_
push_cast
exact Real.sqrt_eq_rpow x.1
| [
" x ^ y = 0 ↔ x = 0 ∧ y ≠ 0",
" ↑x ^ y = ↑0 ↔ ↑x = 0 ∧ y ≠ 0",
" x ^ w = x ^ y * x ^ z",
" y + z ≠ 0",
" x ^ (-1) = x⁻¹",
" (x ^ y) ^ (1 / y) = x",
" (x ^ (1 / y)) ^ y = x",
" sqrt x = x ^ (1 / 2)",
" ↑(sqrt x) = ↑(x ^ (1 / 2))",
" √↑x = ↑x ^ (1 / 2)"
] | [
" x ^ y = 0 ↔ x = 0 ∧ y ≠ 0",
" ↑x ^ y = ↑0 ↔ ↑x = 0 ∧ y ≠ 0",
" x ^ w = x ^ y * x ^ z",
" y + z ≠ 0",
" x ^ (-1) = x⁻¹",
" (x ^ y) ^ (1 / y) = x",
" (x ^ (1 / y)) ^ y = x",
" sqrt x = x ^ (1 / 2)"
] |
import Mathlib.Analysis.Complex.UpperHalfPlane.Topology
import Mathlib.Analysis.SpecialFunctions.Arsinh
import Mathlib.Geometry.Euclidean.Inversion.Basic
#align_import analysis.complex.upper_half_plane.metric from "leanprover-community/mathlib"@"caa58cbf5bfb7f81ccbaca4e8b8ac4bc2b39cc1c"
noncomputable section
ope... | Mathlib/Analysis/Complex/UpperHalfPlane/Metric.lean | 96 | 98 | theorem dist_eq_iff_eq_sinh :
dist z w = r ↔ dist (z : ℂ) w / (2 * √(z.im * w.im)) = sinh (r / 2) := by |
rw [← div_left_inj' (two_ne_zero' ℝ), ← sinh_inj, sinh_half_dist]
| [
" (dist z w / 2).sinh = dist ↑z ↑w / (2 * √(z.im * w.im))",
" (dist z w / 2).cosh = dist (↑z) ((starRingEnd ℂ) ↑w) / (2 * √(z.im * w.im))",
" (2 ^ 2 * (z.im * w.im) + dist ↑z ↑w ^ 2) / (2 ^ 2 * (z.im * w.im)) =\n dist (↑z) ((starRingEnd ℂ) ↑w) ^ 2 / (2 ^ 2 * (z.im * w.im))",
" 2 ^ 2 * (z.im * w.im) + dist ... | [
" (dist z w / 2).sinh = dist ↑z ↑w / (2 * √(z.im * w.im))",
" (dist z w / 2).cosh = dist (↑z) ((starRingEnd ℂ) ↑w) / (2 * √(z.im * w.im))",
" (2 ^ 2 * (z.im * w.im) + dist ↑z ↑w ^ 2) / (2 ^ 2 * (z.im * w.im)) =\n dist (↑z) ((starRingEnd ℂ) ↑w) ^ 2 / (2 ^ 2 * (z.im * w.im))",
" 2 ^ 2 * (z.im * w.im) + dist ... |
import Mathlib.Analysis.Normed.Field.Basic
#align_import topology.metric_space.cau_seq_filter from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
universe u v
open Set Filter
open scoped Classical
open Topology
variable {β : Type v}
theorem CauSeq.tendsto_limit [NormedRing β] [hn : ... | Mathlib/Topology/MetricSpace/CauSeqFilter.lean | 55 | 64 | theorem CauchySeq.isCauSeq {f : ℕ → β} (hf : CauchySeq f) : IsCauSeq norm f := by |
cases' cauchy_iff.1 hf with hf1 hf2
intro ε hε
rcases hf2 { x | dist x.1 x.2 < ε } (dist_mem_uniformity hε) with ⟨t, ⟨ht, htsub⟩⟩
simp only [mem_map, mem_atTop_sets, ge_iff_le, mem_preimage] at ht; cases' ht with N hN
exists N
intro j hj
rw [← dist_eq_norm]
apply @htsub (f j, f N)
apply Set.mk_mem_pr... | [
" ∀ (s : Set β), IsOpen s → f.lim ∈ s → ↑f ⁻¹' s ∈ atTop",
" ↑f ⁻¹' s ∈ atTop",
" ∃ a, ∀ b ≥ a, ↑f b ∈ s",
" ∀ b ≥ N, ↑f b ∈ s",
" ↑f b ∈ s",
" ↑f b ∈ Metric.ball f.lim ε",
" dist (↑f b) f.lim < ε",
" ‖f.lim - ↑f b‖ < ε",
" IsCauSeq norm f",
" ∃ i, ∀ j ≥ i, ‖f j - f i‖ < ε",
" ∀ j ≥ N, ‖f j - f ... | [
" ∀ (s : Set β), IsOpen s → f.lim ∈ s → ↑f ⁻¹' s ∈ atTop",
" ↑f ⁻¹' s ∈ atTop",
" ∃ a, ∀ b ≥ a, ↑f b ∈ s",
" ∀ b ≥ N, ↑f b ∈ s",
" ↑f b ∈ s",
" ↑f b ∈ Metric.ball f.lim ε",
" dist (↑f b) f.lim < ε",
" ‖f.lim - ↑f b‖ < ε",
" IsCauSeq norm f"
] |
import Mathlib.Analysis.Analytic.Basic
import Mathlib.Analysis.Analytic.CPolynomial
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
import Mathlib.Analysis.Calculus.FDeriv.Add
#align_import analysis.calculus.fderiv_analytic from "leanprover-community/mathlib"@"3bce8d800a6f2... | Mathlib/Analysis/Calculus/FDeriv/Analytic.lean | 113 | 122 | theorem AnalyticOn.iteratedFDeriv [CompleteSpace F] (h : AnalyticOn 𝕜 f s) (n : ℕ) :
AnalyticOn 𝕜 (iteratedFDeriv 𝕜 n f) s := by |
induction' n with n IH
· rw [iteratedFDeriv_zero_eq_comp]
exact ((continuousMultilinearCurryFin0 𝕜 E F).symm : F →L[𝕜] E[×0]→L[𝕜] F).comp_analyticOn h
· rw [iteratedFDeriv_succ_eq_comp_left]
-- Porting note: for reasons that I do not understand at all, `?g` cannot be inlined.
convert ContinuousLin... | [
" HasStrictFDerivAt f ((continuousMultilinearCurryFin1 𝕜 E F) (p 1)) x",
" (fun y => ‖y - (x, x)‖ * ‖y.1 - y.2‖) =o[nhds (x, x)] fun x => ‖x.1 - x.2‖",
" Tendsto (fun y => ‖y - (x, x)‖) (nhds (x, x)) (nhds 0)",
" ‖id (x, x) - (x, x)‖ = 0",
" HasFPowerSeriesOnBall (_root_.fderiv 𝕜 f) p.derivSeries x r",
... | [
" HasStrictFDerivAt f ((continuousMultilinearCurryFin1 𝕜 E F) (p 1)) x",
" (fun y => ‖y - (x, x)‖ * ‖y.1 - y.2‖) =o[nhds (x, x)] fun x => ‖x.1 - x.2‖",
" Tendsto (fun y => ‖y - (x, x)‖) (nhds (x, x)) (nhds 0)",
" ‖id (x, x) - (x, x)‖ = 0",
" HasFPowerSeriesOnBall (_root_.fderiv 𝕜 f) p.derivSeries x r",
... |
import Mathlib.Algebra.Order.Ring.Nat
#align_import data.nat.dist from "leanprover-community/mathlib"@"d50b12ae8e2bd910d08a94823976adae9825718b"
namespace Nat
def dist (n m : ℕ) :=
n - m + (m - n)
#align nat.dist Nat.dist
-- Should be aligned to `Nat.dist.eq_def`, but that is generated on demand and isn't pr... | Mathlib/Data/Nat/Dist.lean | 99 | 100 | theorem dist_mul_right (n k m : ℕ) : dist (n * k) (m * k) = dist n m * k := by |
rw [dist, dist, right_distrib, tsub_mul n, tsub_mul m]
| [
" n.dist m = m.dist n",
" n.dist n = 0",
" n.dist m = 0",
" n.dist m = m - n",
" n.dist m = n - m",
" m.dist n = n - m",
" m ≤ n + n.dist m",
" m ≤ n.dist m + n",
" n ≤ n.dist m + m",
" n ≤ m.dist n + m",
" n ≤ m + n.dist m",
" n ≤ m + m.dist n",
" n + k - (m + k) + (m + k - (n + k)) = n - m... | [
" n.dist m = m.dist n",
" n.dist n = 0",
" n.dist m = 0",
" n.dist m = m - n",
" n.dist m = n - m",
" m.dist n = n - m",
" m ≤ n + n.dist m",
" m ≤ n.dist m + n",
" n ≤ n.dist m + m",
" n ≤ m.dist n + m",
" n ≤ m + n.dist m",
" n ≤ m + m.dist n",
" n + k - (m + k) + (m + k - (n + k)) = n - m... |
import Mathlib.MeasureTheory.OuterMeasure.Operations
import Mathlib.Analysis.SpecificLimits.Basic
#align_import measure_theory.measure.outer_measure from "leanprover-community/mathlib"@"343e80208d29d2d15f8050b929aa50fe4ce71b55"
noncomputable section
open Set Function Filter
open scoped Classical NNReal Topology E... | Mathlib/MeasureTheory/OuterMeasure/OfFunction.lean | 139 | 169 | theorem ofFunction_union_of_top_of_nonempty_inter {s t : Set α}
(h : ∀ u, (s ∩ u).Nonempty → (t ∩ u).Nonempty → m u = ∞) :
OuterMeasure.ofFunction m m_empty (s ∪ t) =
OuterMeasure.ofFunction m m_empty s + OuterMeasure.ofFunction m m_empty t := by |
refine le_antisymm (measure_union_le _ _) (le_iInf₂ fun f hf ↦ ?_)
set μ := OuterMeasure.ofFunction m m_empty
rcases Classical.em (∃ i, (s ∩ f i).Nonempty ∧ (t ∩ f i).Nonempty) with (⟨i, hs, ht⟩ | he)
· calc
μ s + μ t ≤ ∞ := le_top
_ = m (f i) := (h (f i) hs ht).symm
_ ≤ ∑' i, m (f i) := ENNR... | [
" ∑' (i : ℕ), m ((fun x => ∅) i) ≤ 0",
" ∀ (ε : ℝ≥0), 0 < ε → ∑' (i : ℕ), μ (s i) < ⊤ → μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ↑ε",
" μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ↑ε",
" μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ∑' (i : ℕ), ↑(ε' i)",
" μ (⋃ i, s i) ≤ ∑' (a : ℕ), (μ (s a) + ↑(ε' a))",
" ∀ (i : ℕ), ∃ f, s ... | [
" ∑' (i : ℕ), m ((fun x => ∅) i) ≤ 0",
" ∀ (ε : ℝ≥0), 0 < ε → ∑' (i : ℕ), μ (s i) < ⊤ → μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ↑ε",
" μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ↑ε",
" μ (⋃ i, s i) ≤ ∑' (i : ℕ), μ (s i) + ∑' (i : ℕ), ↑(ε' i)",
" μ (⋃ i, s i) ≤ ∑' (a : ℕ), (μ (s a) + ↑(ε' a))",
" ∀ (i : ℕ), ∃ f, s ... |
import Mathlib.FieldTheory.Minpoly.Field
#align_import ring_theory.power_basis from "leanprover-community/mathlib"@"d1d69e99ed34c95266668af4e288fc1c598b9a7f"
open Polynomial
open Polynomial
variable {R S T : Type*} [CommRing R] [Ring S] [Algebra R S]
variable {A B : Type*} [CommRing A] [CommRing B] [IsDomain B]... | Mathlib/RingTheory/PowerBasis.lean | 425 | 438 | theorem linearIndependent_pow [Algebra K S] (x : S) :
LinearIndependent K fun i : Fin (minpoly K x).natDegree => x ^ (i : ℕ) := by |
by_cases h : IsIntegral K x; swap
· rw [minpoly.eq_zero h, natDegree_zero]
exact linearIndependent_empty_type
refine Fintype.linearIndependent_iff.2 fun g hg i => ?_
simp only at hg
simp_rw [Algebra.smul_def, ← aeval_monomial, ← map_sum] at hg
apply (fun hn0 => (minpoly.degree_le_of_ne_zero K x (mt (fu... | [
" FiniteDimensional.finrank R S = pb.dim",
" y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.degree < ↑d ∧ y = (aeval x) f",
" (Set.range fun i => x ^ ↑i) = (fun i => x ^ i) '' ↑(Finset.range d)",
" (n ∈ Set.range fun i => x ^ ↑i) ↔ n ∈ (fun i => x ^ i) '' ↑(Finset.range d)",
" (∃ y, x ^ ↑y = n) ↔... | [
" FiniteDimensional.finrank R S = pb.dim",
" y ∈ Submodule.span R (Set.range fun i => x ^ ↑i) ↔ ∃ f, f.degree < ↑d ∧ y = (aeval x) f",
" (Set.range fun i => x ^ ↑i) = (fun i => x ^ i) '' ↑(Finset.range d)",
" (n ∈ Set.range fun i => x ^ ↑i) ↔ n ∈ (fun i => x ^ i) '' ↑(Finset.range d)",
" (∃ y, x ^ ↑y = n) ↔... |
import Mathlib.LinearAlgebra.CliffordAlgebra.Conjugation
import Mathlib.LinearAlgebra.CliffordAlgebra.Even
import Mathlib.LinearAlgebra.QuadraticForm.Prod
import Mathlib.Tactic.LiftLets
#align_import linear_algebra.clifford_algebra.even_equiv from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36d... | Mathlib/LinearAlgebra/CliffordAlgebra/EvenEquiv.lean | 95 | 96 | theorem e0_mul_v_mul_e0 (m : M) : e0 Q * v Q m * e0 Q = v Q m := by |
rw [← neg_v_mul_e0, ← neg_mul, mul_assoc, e0_mul_e0, mul_neg_one, neg_neg]
| [
" (ι (Q' Q)) (m, r) = (v Q) m + r • e0 Q",
" (algebraMap R (CliffordAlgebra (Q' Q))) ((Q' Q) (0, 1)) = -1",
" (algebraMap R (CliffordAlgebra (Q' Q))) ((Q' Q) ((LinearMap.inl R M R) m)) =\n (algebraMap R (CliffordAlgebra (Q' Q))) (Q m)",
" -(e0 Q * (v Q) m) = (v Q) m * e0 Q",
" (algebraMap R (CliffordAlge... | [
" (ι (Q' Q)) (m, r) = (v Q) m + r • e0 Q",
" (algebraMap R (CliffordAlgebra (Q' Q))) ((Q' Q) (0, 1)) = -1",
" (algebraMap R (CliffordAlgebra (Q' Q))) ((Q' Q) ((LinearMap.inl R M R) m)) =\n (algebraMap R (CliffordAlgebra (Q' Q))) (Q m)",
" -(e0 Q * (v Q) m) = (v Q) m * e0 Q",
" (algebraMap R (CliffordAlge... |
import Mathlib.Data.Int.ModEq
import Mathlib.GroupTheory.QuotientGroup
#align_import algebra.modeq from "leanprover-community/mathlib"@"a07d750983b94c530ab69a726862c2ab6802b38c"
namespace AddCommGroup
variable {α : Type*}
section AddCommGroup
variable [AddCommGroup α] {p a a₁ a₂ b b₁ b₂ c : α} {n : ℕ} {z : ℤ}
... | Mathlib/Algebra/ModEq.lean | 262 | 263 | theorem modEq_sub_iff_add_modEq' : a ≡ b - c [PMOD p] ↔ c + a ≡ b [PMOD p] := by |
simp [ModEq, sub_sub]
| [
" a - a = 0 • p",
" (∃ b_1, b - a = (Equiv.symm (Equiv.neg ℤ)) b_1 • p) ↔ b ≡ a [PMOD p]",
" c - a = (m + n) • p",
" -b ≡ -a [PMOD p] ↔ a ≡ b [PMOD p]",
" b ≡ a [PMOD -p] ↔ a ≡ b [PMOD p]",
" a ≡ b [PMOD 0] ↔ a = b",
" 0 - p = -1 • p",
" 0 - z • p = -z • p",
" a - (a + z • p) = -z • p",
" a - (z •... | [
" a - a = 0 • p",
" (∃ b_1, b - a = (Equiv.symm (Equiv.neg ℤ)) b_1 • p) ↔ b ≡ a [PMOD p]",
" c - a = (m + n) • p",
" -b ≡ -a [PMOD p] ↔ a ≡ b [PMOD p]",
" b ≡ a [PMOD -p] ↔ a ≡ b [PMOD p]",
" a ≡ b [PMOD 0] ↔ a = b",
" 0 - p = -1 • p",
" 0 - z • p = -z • p",
" a - (a + z • p) = -z • p",
" a - (z •... |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.LinearAlgebra.AffineSpace.Slope
#align_import analysis.calculus.deriv.slope from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
universe u v w
noncomputable section
open Topology Filter TopologicalSpace
open Filter Set
secti... | Mathlib/Analysis/Calculus/Deriv/Slope.lean | 72 | 74 | theorem hasDerivWithinAt_iff_tendsto_slope' (hs : x ∉ s) :
HasDerivWithinAt f f' s x ↔ Tendsto (slope f x) (𝓝[s] x) (𝓝 f') := by |
rw [hasDerivWithinAt_iff_tendsto_slope, diff_singleton_eq_self hs]
| [
" HasDerivAtFilter f f' x L ↔ Tendsto (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') L (𝓝 0)",
" ∀ a ∉ {x}ᶜ, slope f x a - (a - x)⁻¹ • (a - x) • f' = 0",
" (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') =ᶠ[L ⊓ 𝓟 {x}ᶜ] fun y => slope f x y - f'",
" slope f x y - (y - x)⁻¹ • (y - x) • f' = slope f x y -... | [
" HasDerivAtFilter f f' x L ↔ Tendsto (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') L (𝓝 0)",
" ∀ a ∉ {x}ᶜ, slope f x a - (a - x)⁻¹ • (a - x) • f' = 0",
" (fun y => slope f x y - (y - x)⁻¹ • (y - x) • f') =ᶠ[L ⊓ 𝓟 {x}ᶜ] fun y => slope f x y - f'",
" slope f x y - (y - x)⁻¹ • (y - x) • f' = slope f x y -... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Topology.Instances.Real
import Mathlib.Topology.Instances.ENNReal
#align_import topology.algebra.infinite_sum.real from "leanprover-community/mathlib"@"9a59dcb7a2d06bf55da57b9030169219980660cd"
open Filte... | Mathlib/Topology/Algebra/InfiniteSum/Real.lean | 39 | 46 | theorem dist_le_tsum_of_dist_le_of_tendsto (d : ℕ → ℝ) (hf : ∀ n, dist (f n) (f n.succ) ≤ d n)
(hd : Summable d) {a : α} (ha : Tendsto f atTop (𝓝 a)) (n : ℕ) :
dist (f n) a ≤ ∑' m, d (n + m) := by |
refine le_of_tendsto (tendsto_const_nhds.dist ha) (eventually_atTop.2 ⟨n, fun m hnm ↦ ?_⟩)
refine le_trans (dist_le_Ico_sum_of_dist_le hnm fun _ _ ↦ hf _) ?_
rw [sum_Ico_eq_sum_range]
refine sum_le_tsum (range _) (fun _ _ ↦ le_trans dist_nonneg (hf _)) ?_
exact hd.comp_injective (add_right_injective n)
| [
" CauchySeq f",
" ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)",
" Summable d",
" dist (f n) a ≤ ∑' (m : ℕ), d (n + m)",
" dist (f n) (f m) ≤ ∑' (m : ℕ), d (n + m)",
" ∑ i ∈ Ico n m, d i ≤ ∑' (m : ℕ), d (n + m)",
" ∑ k ∈ range (m - n), d (n + k) ≤ ∑' (m : ℕ), d (n + m)",
" Summable fun k => d (n + k)"
] | [
" CauchySeq f",
" ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)",
" Summable d",
" dist (f n) a ≤ ∑' (m : ℕ), d (n + m)"
] |
import Mathlib.SetTheory.Cardinal.Ordinal
#align_import set_theory.cardinal.continuum from "leanprover-community/mathlib"@"e08a42b2dd544cf11eba72e5fc7bf199d4349925"
namespace Cardinal
universe u v
open Cardinal
def continuum : Cardinal.{u} :=
2 ^ ℵ₀
#align cardinal.continuum Cardinal.continuum
scoped notat... | Mathlib/SetTheory/Cardinal/Continuum.lean | 41 | 42 | theorem lift_continuum : lift.{v} 𝔠 = 𝔠 := by |
rw [← two_power_aleph0, lift_two_power, lift_aleph0, two_power_aleph0]
| [
" lift.{v, u_1} 𝔠 = 𝔠"
] | [
" lift.{v, u_1} 𝔠 = 𝔠"
] |
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Topology.Algebra.InfiniteSum.Ring
import Mathlib.Topology.Instances.Real
import Mathlib.Topology.MetricSpace.Isometry
#align_import topology.instances.nnreal from "leanprover-community/mathlib"@"32253a1a1071173b33dc7d6a218cf722c6feb514"
noncomputabl... | Mathlib/Topology/Instances/NNReal.lean | 140 | 142 | theorem _root_.tendsto_real_toNNReal_atTop : Tendsto Real.toNNReal atTop atTop := by |
rw [← tendsto_coe_atTop]
exact tendsto_atTop_mono Real.le_coe_toNNReal tendsto_id
| [
" Tendsto Real.toNNReal atTop atTop",
" Tendsto (fun a => ↑a.toNNReal) atTop atTop"
] | [
" Tendsto Real.toNNReal atTop atTop"
] |
import Mathlib.Probability.Independence.Basic
import Mathlib.Probability.Independence.Conditional
#align_import probability.independence.zero_one from "leanprover-community/mathlib"@"2f8347015b12b0864dfaf366ec4909eb70c78740"
open MeasureTheory MeasurableSpace
open scoped MeasureTheory ENNReal
namespace Probabili... | Mathlib/Probability/Independence/ZeroOne.lean | 58 | 61 | theorem measure_eq_zero_or_one_of_indepSet_self [IsFiniteMeasure μ] {t : Set Ω}
(h_indep : IndepSet t t μ) : μ t = 0 ∨ μ t = 1 := by |
simpa only [ae_dirac_eq, Filter.eventually_pure]
using kernel.measure_eq_zero_or_one_of_indepSet_self h_indep
| [
" ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤",
" (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤",
" μ t = 0 ∨ μ t = 1 ∨ μ t = ⊤",
" ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1",
" (κ a) t = 0 ∨ (κ a) t = 1",
" μ t = 0 ∨ μ t = 1"
] | [
" ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤",
" (κ a) t = 0 ∨ (κ a) t = 1 ∨ (κ a) t = ⊤",
" μ t = 0 ∨ μ t = 1 ∨ μ t = ⊤",
" ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1",
" (κ a) t = 0 ∨ (κ a) t = 1",
" μ t = 0 ∨ μ t = 1"
] |
import Mathlib.Algebra.Order.Monoid.Defs
import Mathlib.Algebra.Order.Sub.Defs
import Mathlib.Util.AssertExists
#align_import algebra.order.group.defs from "leanprover-community/mathlib"@"b599f4e4e5cf1fbcb4194503671d3d9e569c1fce"
open Function
universe u
variable {α : Type u}
class OrderedAddCommGroup (α : Ty... | Mathlib/Algebra/Order/Group/Defs.lean | 305 | 306 | theorem mul_inv_lt_iff_lt_mul : a * b⁻¹ < c ↔ a < c * b := by |
rw [← mul_lt_mul_iff_right b, inv_mul_cancel_right]
| [
" b ≤ c",
" a⁻¹ < 1 ↔ 1 < a",
" 1 < a⁻¹ ↔ a < 1",
" a⁻¹ * a < b * a ↔ 1 < b * a",
" a * b < b⁻¹ * b ↔ a * b < 1",
" a * b⁻¹ < c ↔ a < c * b"
] | [
" b ≤ c",
" a⁻¹ < 1 ↔ 1 < a",
" 1 < a⁻¹ ↔ a < 1",
" a⁻¹ * a < b * a ↔ 1 < b * a",
" a * b < b⁻¹ * b ↔ a * b < 1",
" a * b⁻¹ < c ↔ a < c * b"
] |
import Mathlib.Init.Function
#align_import data.option.n_ary from "leanprover-community/mathlib"@"995b47e555f1b6297c7cf16855f1023e355219fb"
universe u
open Function
namespace Option
variable {α β γ δ : Type*} {f : α → β → γ} {a : Option α} {b : Option β} {c : Option γ}
def map₂ (f : α → β → γ) (a : Option α) ... | Mathlib/Data/Option/NAry.lean | 78 | 79 | theorem mem_map₂_iff {c : γ} : c ∈ map₂ f a b ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c := by |
simp [map₂, bind_eq_some]
| [
" map₂ f a b = Seq.seq (f <$> a) fun x => b",
" map₂ f none b = Seq.seq (f <$> none) fun x => b",
" map₂ f (some val✝) b = Seq.seq (f <$> some val✝) fun x => b",
" map₂ f a none = none",
" map₂ f none none = none",
" map₂ f (some val✝) none = none",
" map₂ f a (some b) = Option.map (fun a => f a b) a",
... | [
" map₂ f a b = Seq.seq (f <$> a) fun x => b",
" map₂ f none b = Seq.seq (f <$> none) fun x => b",
" map₂ f (some val✝) b = Seq.seq (f <$> some val✝) fun x => b",
" map₂ f a none = none",
" map₂ f none none = none",
" map₂ f (some val✝) none = none",
" map₂ f a (some b) = Option.map (fun a => f a b) a",
... |
import Mathlib.Algebra.Algebra.Pi
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.RingTheory.Adjoin.Basic
#align_import data.polynomial.algebra_map from "leanprover-community/mathlib"@"e064a7bf82ad94c3c17b5128bbd860d1ec34874e"
noncomputable section
open Finset
open Polynomial
namespace Polynomial
univer... | Mathlib/Algebra/Polynomial/AlgebraMap.lean | 123 | 127 | theorem algHom_eval₂_algebraMap {R A B : Type*} [CommSemiring R] [Semiring A] [Semiring B]
[Algebra R A] [Algebra R B] (p : R[X]) (f : A →ₐ[R] B) (a : A) :
f (eval₂ (algebraMap R A) a p) = eval₂ (algebraMap R B) (f a) p := by |
simp only [eval₂_eq_sum, sum_def]
simp only [f.map_sum, f.map_mul, f.map_pow, eq_intCast, map_intCast, AlgHom.commutes]
| [
" ((C.comp (algebraMap R A)) r * p).toFinsupp = (p * (C.comp (algebraMap R A)) r).toFinsupp",
" (C ((algebraMap R A) r) * p).toFinsupp = (p * C ((algebraMap R A) r)).toFinsupp",
" AddMonoidAlgebra.single 0 ((algebraMap R A) r) * p.toFinsupp =\n p.toFinsupp * AddMonoidAlgebra.single 0 ((algebraMap R A) r)",
... | [
" ((C.comp (algebraMap R A)) r * p).toFinsupp = (p * (C.comp (algebraMap R A)) r).toFinsupp",
" (C ((algebraMap R A) r) * p).toFinsupp = (p * C ((algebraMap R A) r)).toFinsupp",
" AddMonoidAlgebra.single 0 ((algebraMap R A) r) * p.toFinsupp =\n p.toFinsupp * AddMonoidAlgebra.single 0 ((algebraMap R A) r)",
... |
import Mathlib.Data.Set.Function
import Mathlib.Order.Interval.Set.OrdConnected
#align_import data.set.intervals.proj_Icc from "leanprover-community/mathlib"@"4e24c4bfcff371c71f7ba22050308aa17815626c"
variable {α β : Type*} [LinearOrder α]
open Function
namespace Set
def projIci (a x : α) : Ici a := ⟨max a x,... | Mathlib/Order/Interval/Set/ProjIcc.lean | 119 | 120 | theorem projIcc_of_mem (hx : x ∈ Icc a b) : projIcc a b h x = ⟨x, hx⟩ := by |
simp [projIcc, hx.1, hx.2]
| [
" projIcc a b h x = ⟨a, ⋯⟩",
" projIcc a b h x = ⟨b, ⋯⟩",
" projIci a x = ⟨a, ⋯⟩ ↔ x ≤ a",
" projIic b x = ⟨b, ⋯⟩ ↔ b ≤ x",
" projIcc a b ⋯ x = ⟨a, ⋯⟩ ↔ x ≤ a",
" projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x",
" projIci a x = ⟨x, hx⟩",
" projIic b x = ⟨x, hx⟩",
" projIcc a b h x = ⟨x, hx⟩"
] | [
" projIcc a b h x = ⟨a, ⋯⟩",
" projIcc a b h x = ⟨b, ⋯⟩",
" projIci a x = ⟨a, ⋯⟩ ↔ x ≤ a",
" projIic b x = ⟨b, ⋯⟩ ↔ b ≤ x",
" projIcc a b ⋯ x = ⟨a, ⋯⟩ ↔ x ≤ a",
" projIcc a b ⋯ x = ⟨b, ⋯⟩ ↔ b ≤ x",
" projIci a x = ⟨x, hx⟩",
" projIic b x = ⟨x, hx⟩",
" projIcc a b h x = ⟨x, hx⟩"
] |
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
#align_import geometry.euclidean.circumcenter from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
noncomputable section
open scoped Classical
o... | Mathlib/Geometry/Euclidean/Circumcenter.lean | 91 | 179 | theorem existsUnique_dist_eq_of_insert {s : AffineSubspace ℝ P}
[HasOrthogonalProjection s.direction] {ps : Set P} (hnps : ps.Nonempty) {p : P} (hps : ps ⊆ s)
(hp : p ∉ s) (hu : ∃! cs : Sphere P, cs.center ∈ s ∧ ps ⊆ (cs : Set P)) :
∃! cs₂ : Sphere P,
cs₂.center ∈ affineSpan ℝ (insert p (s : Set P)) ∧... |
haveI : Nonempty s := Set.Nonempty.to_subtype (hnps.mono hps)
rcases hu with ⟨⟨cc, cr⟩, ⟨hcc, hcr⟩, hcccru⟩
simp only at hcc hcr hcccru
let x := dist cc (orthogonalProjection s p)
let y := dist p (orthogonalProjection s p)
have hy0 : y ≠ 0 := dist_orthogonalProjection_ne_zero_of_not_mem hp
let ycc₂ := (x... | [
" dist p1 p3 = dist p2 p3 ↔ dist p1 ↑((orthogonalProjection s) p3) = dist p2 ↑((orthogonalProjection s) p3)",
" dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) +\n dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) =\n dist p2 ↑((orthogonalP... | [
" dist p1 p3 = dist p2 p3 ↔ dist p1 ↑((orthogonalProjection s) p3) = dist p2 ↑((orthogonalProjection s) p3)",
" dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) +\n dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) =\n dist p2 ↑((orthogonalP... |
import Mathlib.Topology.CompactOpen
import Mathlib.Topology.Sets.Closeds
open Function Set Filter TopologicalSpace
open scoped Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [CompactSpace Y]
| Mathlib/Topology/ClopenBox.lean | 36 | 44 | theorem TopologicalSpace.Clopens.exists_prod_subset (W : Clopens (X × Y)) {a : X × Y} (h : a ∈ W) :
∃ U : Clopens X, a.1 ∈ U ∧ ∃ V : Clopens Y, a.2 ∈ V ∧ U ×ˢ V ≤ W := by |
have hp : Continuous (fun y : Y ↦ (a.1, y)) := Continuous.Prod.mk _
let V : Set Y := {y | (a.1, y) ∈ W}
have hV : IsCompact V := (W.2.1.preimage hp).isCompact
let U : Set X := {x | MapsTo (Prod.mk x) V W}
have hUV : U ×ˢ V ⊆ W := fun ⟨_, _⟩ hw ↦ hw.1 hw.2
exact ⟨⟨U, (ContinuousMap.isClopen_setOf_mapsTo hV ... | [
" ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W",
" a.1 ∈ { carrier := U, isClopen' := ⋯ }"
] | [
" ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W"
] |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.Calculus.Deriv.Mul
import Mathlib.Analysis.Calculus.Deriv.Shift
import Mathlib.Analysis.Calculus.IteratedDeriv.Defs
variable
{𝕜 : Type*} [NontriviallyNormedField 𝕜]
{F : Type*} [NormedAddCommGroup F] [NormedSpace 𝕜 F]
{R : Type*} [Semi... | Mathlib/Analysis/Calculus/IteratedDeriv/Lemmas.lean | 79 | 83 | theorem iteratedDerivWithin_sub (hf : ContDiffOn 𝕜 n f s) (hg : ContDiffOn 𝕜 n g s) :
iteratedDerivWithin n (f - g) s x =
iteratedDerivWithin n f s x - iteratedDerivWithin n g s x := by |
rw [sub_eq_add_neg, sub_eq_add_neg, Pi.neg_def, iteratedDerivWithin_add hx h hf hg.neg,
iteratedDerivWithin_neg' hx h]
| [
" iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x",
" Set.EqOn (iteratedDerivWithin n f s) (iteratedDerivWithin n g s) s",
" Set.EqOn (iteratedDerivWithin 0 f s) (iteratedDerivWithin 0 g s) s",
" Set.EqOn (iteratedDerivWithin (n + 1) f s) (iteratedDerivWithin (n +... | [
" iteratedDerivWithin n (f + g) s x = iteratedDerivWithin n f s x + iteratedDerivWithin n g s x",
" Set.EqOn (iteratedDerivWithin n f s) (iteratedDerivWithin n g s) s",
" Set.EqOn (iteratedDerivWithin 0 f s) (iteratedDerivWithin 0 g s) s",
" Set.EqOn (iteratedDerivWithin (n + 1) f s) (iteratedDerivWithin (n +... |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Monic
#align_import data.polynomial.lifts from "leanprover-community/mathlib"@"63417e01fbc711beaf25fa73b6edb395c0cfddd0"
open Polynomial
noncomputable section
namespace Polynomial
universe u v w
section Semiring
variable {R : Type... | Mathlib/Algebra/Polynomial/Lifts.lean | 112 | 116 | theorem base_mul_mem_lifts {p : S[X]} (r : R) (hp : p ∈ lifts f) : C (f r) * p ∈ lifts f := by |
simp only [lifts, RingHom.mem_rangeS] at hp ⊢
obtain ⟨p₁, rfl⟩ := hp
use C r * p₁
simp only [coe_mapRingHom, map_C, map_mul]
| [
" p ∈ lifts f ↔ ∃ q, map f q = p",
" p ∈ lifts f ↔ p ∈ Set.range (map f)",
" p ∈ lifts f ↔ p ∈ (mapRingHom f).rangeS",
" p ∈ lifts f ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (∀ (n : ℕ), p.coeff n ∈ f.rangeS) ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (mapRingHom f) (C r) = C (f r)",
" C s ∈ lifts f",
... | [
" p ∈ lifts f ↔ ∃ q, map f q = p",
" p ∈ lifts f ↔ p ∈ Set.range (map f)",
" p ∈ lifts f ↔ p ∈ (mapRingHom f).rangeS",
" p ∈ lifts f ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (∀ (n : ℕ), p.coeff n ∈ f.rangeS) ↔ ∀ (n : ℕ), p.coeff n ∈ Set.range ⇑f",
" (mapRingHom f) (C r) = C (f r)",
" C s ∈ lifts f",
... |
import Mathlib.Algebra.MvPolynomial.PDeriv
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Derivative
import Mathlib.Data.Nat.Choose.Sum
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.RingTheory.Polynomial.Pochhammer
#align_import ring_theory.polynomial.bernstein from "le... | Mathlib/RingTheory/Polynomial/Bernstein.lean | 134 | 138 | theorem derivative_succ (n ν : ℕ) : Polynomial.derivative (bernsteinPolynomial R n (ν + 1)) =
n * (bernsteinPolynomial R (n - 1) ν - bernsteinPolynomial R (n - 1) (ν + 1)) := by |
cases n
· simp [bernsteinPolynomial]
· rw [Nat.cast_succ]; apply derivative_succ_aux
| [
" bernsteinPolynomial ℤ 3 2 = 3 * X ^ 2 - 3 * X ^ 3",
" 3 * X ^ 2 * (1 - X) = 3 * X ^ 2 - 3 * X ^ 3",
" bernsteinPolynomial R n ν = 0",
" Polynomial.map f (bernsteinPolynomial R n ν) = bernsteinPolynomial S n ν",
" (bernsteinPolynomial R n ν).comp (1 - X) = bernsteinPolynomial R n (n - ν)",
" bernsteinPol... | [
" bernsteinPolynomial ℤ 3 2 = 3 * X ^ 2 - 3 * X ^ 3",
" 3 * X ^ 2 * (1 - X) = 3 * X ^ 2 - 3 * X ^ 3",
" bernsteinPolynomial R n ν = 0",
" Polynomial.map f (bernsteinPolynomial R n ν) = bernsteinPolynomial S n ν",
" (bernsteinPolynomial R n ν).comp (1 - X) = bernsteinPolynomial R n (n - ν)",
" bernsteinPol... |
import Mathlib.Algebra.Group.Support
import Mathlib.Data.Set.Pointwise.SMul
#align_import data.set.pointwise.support from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
open Pointwise
open Function Set
section Group
variable {α β γ : Type*} [Group α] [MulAction α β]
theorem mulSuppo... | Mathlib/Data/Set/Pointwise/Support.lean | 34 | 37 | theorem support_comp_inv_smul [Zero γ] (c : α) (f : β → γ) :
(support fun x ↦ f (c⁻¹ • x)) = c • support f := by |
ext x
simp only [mem_smul_set_iff_inv_smul_mem, mem_support]
| [
" (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f",
" (x ∈ mulSupport fun x => f (c⁻¹ • x)) ↔ x ∈ c • mulSupport f",
" (support fun x => f (c⁻¹ • x)) = c • support f",
" (x ∈ support fun x => f (c⁻¹ • x)) ↔ x ∈ c • support f"
] | [
" (mulSupport fun x => f (c⁻¹ • x)) = c • mulSupport f",
" (x ∈ mulSupport fun x => f (c⁻¹ • x)) ↔ x ∈ c • mulSupport f",
" (support fun x => f (c⁻¹ • x)) = c • support f"
] |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Order.SupIndep
import Mathlib.Order.Atoms
#align_import order.partition.finpartition from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
open Finset Function
variable {α : Type*}
@[ext]
structure Finpartition [Lattice α]... | Mathlib/Order/Partition/Finpartition.lean | 199 | 200 | theorem parts_nonempty_iff : P.parts.Nonempty ↔ a ≠ ⊥ := by |
rw [nonempty_iff_ne_empty, not_iff_not, parts_eq_empty_iff]
| [
" x✝ ≤ ⊥",
" (↑e).symm x✝¹ ∉ Finset.map (↑e).symm.toEmbedding u",
" e.symm x✝ ≤ (Finset.map (↑e).symm.toEmbedding u).sup id",
" (Finset.map (↑e).symm.toEmbedding u).sup id = e.symm (u.sup id)",
" u.sup (id ∘ ⇑(↑e).symm.toEmbedding) = u.sup (⇑e.symm ∘ id)",
" (Finset.map (↑e).toEmbedding P.parts).sup id = ... | [
" x✝ ≤ ⊥",
" (↑e).symm x✝¹ ∉ Finset.map (↑e).symm.toEmbedding u",
" e.symm x✝ ≤ (Finset.map (↑e).symm.toEmbedding u).sup id",
" (Finset.map (↑e).symm.toEmbedding u).sup id = e.symm (u.sup id)",
" u.sup (id ∘ ⇑(↑e).symm.toEmbedding) = u.sup (⇑e.symm ∘ id)",
" (Finset.map (↑e).toEmbedding P.parts).sup id = ... |
import Mathlib.Algebra.MvPolynomial.Monad
#align_import data.mv_polynomial.expand from "leanprover-community/mathlib"@"5da451b4c96b4c2e122c0325a7fce17d62ee46c6"
namespace MvPolynomial
variable {σ τ R S : Type*} [CommSemiring R] [CommSemiring S]
noncomputable def expand (p : ℕ) : MvPolynomial σ R →ₐ[R] MvPolyno... | Mathlib/Algebra/MvPolynomial/Expand.lean | 77 | 78 | theorem map_expand (f : R →+* S) (p : ℕ) (φ : MvPolynomial σ R) :
map f (expand p φ) = expand p (map f φ) := by | simp [expand, map_bind₁]
| [
" (expand 1) f = f",
" expand 1 = AlgHom.id R (MvPolynomial σ R)",
" (expand 1) (X f) = (AlgHom.id R (MvPolynomial σ R)) (X f)",
" (expand p).comp (bind₁ f) = bind₁ fun i => (expand p) (f i)",
" ∀ (i : σ), ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)",
" ((expand p).comp (bi... | [
" (expand 1) f = f",
" expand 1 = AlgHom.id R (MvPolynomial σ R)",
" (expand 1) (X f) = (AlgHom.id R (MvPolynomial σ R)) (X f)",
" (expand p).comp (bind₁ f) = bind₁ fun i => (expand p) (f i)",
" ∀ (i : σ), ((expand p).comp (bind₁ f)) (X i) = (bind₁ fun i => (expand p) (f i)) (X i)",
" ((expand p).comp (bi... |
import Mathlib.Algebra.ContinuedFractions.Basic
import Mathlib.Algebra.GroupWithZero.Basic
#align_import algebra.continued_fractions.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
section WithDivisionRing
variable {K : Type*}... | Mathlib/Algebra/ContinuedFractions/Translations.lean | 155 | 159 | theorem first_continuant_eq {gp : Pair K} (zeroth_s_eq : g.s.get? 0 = some gp) :
g.continuants 1 = ⟨gp.b * g.h + gp.a, gp.b⟩ := by |
simp [nth_cont_eq_succ_nth_cont_aux]
-- Porting note (#10959): simp used to work here, but now it can't figure out that 1 + 1 = 2
convert second_continuant_aux_eq zeroth_s_eq
| [
" ∃ conts, g.continuants n = conts ∧ conts.a = A",
" ∃ conts, g.continuants n = conts ∧ conts.b = B",
" g.convergents 0 = g.h",
" g.continuantsAux 2 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.continuants 1 = { a := gp.b * g.h + gp.a, b := gp.b }"
] | [
" ∃ conts, g.continuants n = conts ∧ conts.a = A",
" ∃ conts, g.continuants n = conts ∧ conts.b = B",
" g.convergents 0 = g.h",
" g.continuantsAux 2 = { a := gp.b * g.h + gp.a, b := gp.b }",
" g.continuants 1 = { a := gp.b * g.h + gp.a, b := gp.b }"
] |
import Mathlib.Data.Setoid.Partition
import Mathlib.GroupTheory.GroupAction.Basic
import Mathlib.GroupTheory.GroupAction.Pointwise
import Mathlib.GroupTheory.GroupAction.SubMulAction
open scoped BigOperators Pointwise
namespace MulAction
section orbits
variable {G : Type*} [Group G] {X : Type*} [MulAction G X]
... | Mathlib/GroupTheory/GroupAction/Blocks.lean | 51 | 57 | theorem IsPartition.of_orbits :
Setoid.IsPartition (Set.range fun a : X => orbit G a) := by |
apply orbit.pairwiseDisjoint.isPartition_of_exists_of_ne_empty
· intro x
exact ⟨_, ⟨x, rfl⟩, mem_orbit_self x⟩
· rintro ⟨a, ha : orbit G a = ∅⟩
exact (MulAction.orbit_nonempty a).ne_empty ha
| [
" orbit G a = orbit G b ∨ Disjoint (orbit G a) (orbit G b)",
" ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b",
" (Set.range fun x => orbit G x).PairwiseDisjoint id",
" (Disjoint on id) ((fun x => orbit G x) x) ((fun x => orbit G x) y)",
" orbit G x = orbit G y",
" Setoid.IsPartition (Set.range... | [
" orbit G a = orbit G b ∨ Disjoint (orbit G a) (orbit G b)",
" ¬Disjoint (orbit G a) (orbit G b) → orbit G a = orbit G b",
" (Set.range fun x => orbit G x).PairwiseDisjoint id",
" (Disjoint on id) ((fun x => orbit G x) x) ((fun x => orbit G x) y)",
" orbit G x = orbit G y",
" Setoid.IsPartition (Set.range... |
import Mathlib.RingTheory.DedekindDomain.Ideal
import Mathlib.RingTheory.IsAdjoinRoot
#align_import number_theory.kummer_dedekind from "leanprover-community/mathlib"@"65a1391a0106c9204fe45bc73a039f056558cb83"
variable (R : Type*) {S : Type*} [CommRing R] [CommRing S] [Algebra R S]
open Ideal Polynomial DoubleQuo... | Mathlib/NumberTheory/KummerDedekind.lean | 119 | 148 | theorem prod_mem_ideal_map_of_mem_conductor {p : R} {z : S}
(hp : p ∈ Ideal.comap (algebraMap R S) (conductor R x)) (hz' : z ∈ I.map (algebraMap R S)) :
algebraMap R S p * z ∈ algebraMap R<x> S '' ↑(I.map (algebraMap R R<x>)) := by |
rw [Ideal.map, Ideal.span, Finsupp.mem_span_image_iff_total] at hz'
obtain ⟨l, H, H'⟩ := hz'
rw [Finsupp.total_apply] at H'
rw [← H', mul_comm, Finsupp.sum_mul]
have lem : ∀ {a : R}, a ∈ I → l a • algebraMap R S a * algebraMap R S p ∈
algebraMap R<x> S '' I.map (algebraMap R R<x>) := by
intro a ha
... | [
" (a✝ + b✝) * c ∈ adjoin R {x}",
" 0 * b ∈ adjoin R {x}",
" c • a * b ∈ adjoin R {x}",
" y ∈ ↑(adjoin R {x})",
" conductor R x = ⊤",
" y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}",
" y ∈ ⊤ ↔ ∀ (z : S), y * (algebraMap S L) z ∈ ⊤",
" y ∈ coeSub... | [
" (a✝ + b✝) * c ∈ adjoin R {x}",
" 0 * b ∈ adjoin R {x}",
" c • a * b ∈ adjoin R {x}",
" y ∈ ↑(adjoin R {x})",
" conductor R x = ⊤",
" y ∈ coeSubmodule L (conductor R x) ↔ ∀ (z : S), y * (algebraMap S L) z ∈ adjoin R {(algebraMap S L) x}",
" y ∈ ⊤ ↔ ∀ (z : S), y * (algebraMap S L) z ∈ ⊤",
" y ∈ coeSub... |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
#align_import analysis.special_functions.pow.continuity from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter ComplexConjugate
open Filter Finset... | Mathlib/Analysis/SpecialFunctions/Pow/Continuity.lean | 66 | 71 | theorem continuousAt_const_cpow {a b : ℂ} (ha : a ≠ 0) : ContinuousAt (fun x : ℂ => a ^ x) b := by |
have cpow_eq : (fun x : ℂ => a ^ x) = fun x => exp (log a * x) := by
ext1 b
rw [cpow_def_of_ne_zero ha]
rw [cpow_eq]
exact continuous_exp.continuousAt.comp (ContinuousAt.mul continuousAt_const continuousAt_id)
| [
" (fun x => 0 ^ x) =ᶠ[𝓝 b] 0",
" (fun x => 0 ^ x) x = 0 x",
" 0 ^ x = OfNat.ofNat 0 x",
" ∀ᶠ (x : ℂ) in 𝓝 b, x ≠ 0",
" (fun x => x ^ b) =ᶠ[𝓝 a] fun x => cexp (x.log * b)",
" (fun x => x ^ b) x = (fun x => cexp (x.log * b)) x",
" x ^ b = cexp (x.log * b)",
" ∀ᶠ (x : ℂ) in 𝓝 a, x ≠ 0",
" (fun x =>... | [
" (fun x => 0 ^ x) =ᶠ[𝓝 b] 0",
" (fun x => 0 ^ x) x = 0 x",
" 0 ^ x = OfNat.ofNat 0 x",
" ∀ᶠ (x : ℂ) in 𝓝 b, x ≠ 0",
" (fun x => x ^ b) =ᶠ[𝓝 a] fun x => cexp (x.log * b)",
" (fun x => x ^ b) x = (fun x => cexp (x.log * b)) x",
" x ^ b = cexp (x.log * b)",
" ∀ᶠ (x : ℂ) in 𝓝 a, x ≠ 0",
" (fun x =>... |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
import Mathlib.NumberTheory.GaussSum
#align_import number_theory.legendre_symbol.quadratic_char.gauss_sum from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
section SpecialValues
open ZMod MulChar
variable {F : Type*} ... | Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/GaussSum.lean | 72 | 91 | theorem FiniteField.isSquare_neg_two_iff :
IsSquare (-2 : F) ↔ Fintype.card F % 8 ≠ 5 ∧ Fintype.card F % 8 ≠ 7 := by |
classical
by_cases hF : ringChar F = 2
focus
have h := FiniteField.even_card_of_char_two hF
simp only [FiniteField.isSquare_of_char_two hF, true_iff_iff]
rotate_left
focus
have h := FiniteField.odd_card_of_char_ne_two hF
rw [← quadraticChar_one_iff_isSquare (neg_ne_zero.mpr (Ring.two_ne_zero ... | [
" IsSquare 2 ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 ∨ Fintype.card F % 8 = 7 then 1 else -1) = 1 ↔\n Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" -1 ≠ 1",
" Fintype.c... | [
" IsSquare 2 ↔ Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" (if Fintype.card F % 2 = 0 then 0 else if Fintype.card F % 8 = 1 ∨ Fintype.card F % 8 = 7 then 1 else -1) = 1 ↔\n Fintype.card F % 8 ≠ 3 ∧ Fintype.card F % 8 ≠ 5",
" -1 ≠ 1",
" Fintype.c... |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter C... | Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 126 | 128 | theorem tendsto_rpow_neg_div : Tendsto (fun x => x ^ (-(1 : ℝ) / x)) atTop (𝓝 1) := by |
convert tendsto_rpow_div_mul_add (-(1 : ℝ)) _ (0 : ℝ) zero_ne_one
ring
| [
" Tendsto (fun x => x ^ y) atTop atTop",
" ∀ (b : ℝ), ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y",
" ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y",
" ∀ (a : ℝ), max b 0 ^ (1 / y) ≤ a → b ≤ a ^ y",
" b ≤ x ^ y",
" max b ?m.800 ≤ x ^ y",
" max b ?m.800 = (max b 0 ^ (1 / y)) ^ y",
" Tendsto (fun x => b ^ x) atTop (𝓝 0)",
... | [
" Tendsto (fun x => x ^ y) atTop atTop",
" ∀ (b : ℝ), ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y",
" ∃ i, ∀ (a : ℝ), i ≤ a → b ≤ a ^ y",
" ∀ (a : ℝ), max b 0 ^ (1 / y) ≤ a → b ≤ a ^ y",
" b ≤ x ^ y",
" max b ?m.800 ≤ x ^ y",
" max b ?m.800 = (max b 0 ^ (1 / y)) ^ y",
" Tendsto (fun x => b ^ x) atTop (𝓝 0)",
... |
import Mathlib.Data.Finset.Card
#align_import data.finset.option from "leanprover-community/mathlib"@"c227d107bbada5d0d9d20287e3282c0a7f1651a0"
variable {α β : Type*}
open Function
namespace Option
def toFinset (o : Option α) : Finset α :=
o.elim ∅ singleton
#align option.to_finset Option.toFinset
@[simp]
... | Mathlib/Data/Finset/Option.lean | 51 | 52 | theorem mem_toFinset {a : α} {o : Option α} : a ∈ o.toFinset ↔ a ∈ o := by |
cases o <;> simp [eq_comm]
| [
" a ∈ o.toFinset ↔ a ∈ o",
" a ∈ none.toFinset ↔ a ∈ none",
" a ∈ (some val✝).toFinset ↔ a ∈ some val✝"
] | [
" a ∈ o.toFinset ↔ a ∈ o"
] |
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Topology.Algebra.Module.Basic
import Mathlib.RingTheory.Adjoin.Basic
#align_import topology.algebra.algebra from "leanprover-community/mathlib"@"43afc5ad87891456c57b5a183e3e617d67c2b1db"
open scoped Classical
open Set TopologicalSpace Algebra
open sc... | Mathlib/Topology/Algebra/Algebra.lean | 42 | 44 | theorem continuous_algebraMap [ContinuousSMul R A] : Continuous (algebraMap R A) := by |
rw [algebraMap_eq_smul_one']
exact continuous_id.smul continuous_const
| [
" Continuous ⇑(algebraMap R A)",
" Continuous fun r => r • 1"
] | [
" Continuous ⇑(algebraMap R A)"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.HasseDeriv
#align_import data.polynomial.taylor from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
noncomputable section
namespace Polynomial
open Polynomial... | Mathlib/Algebra/Polynomial/Taylor.lean | 116 | 118 | theorem taylor_taylor {R} [CommSemiring R] (f : R[X]) (r s : R) :
taylor r (taylor s f) = taylor (r + s) f := by |
simp only [taylor_apply, comp_assoc, map_add, add_comp, X_comp, C_comp, C_add, add_assoc]
| [
" { toFun := fun f => f.comp (X + C r), map_add' := ⋯ }.toFun (c • f) =\n (RingHom.id R) c • { toFun := fun f => f.comp (X + C r), map_add' := ⋯ }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ∘ₗ monomial n✝¹) 1).coeff n✝ = ((LinearMap.id ∘ₗ mono... | [
" { toFun := fun f => f.comp (X + C r), map_add' := ⋯ }.toFun (c • f) =\n (RingHom.id R) c • { toFun := fun f => f.comp (X + C r), map_add' := ⋯ }.toFun f",
" (taylor r) X = X + C r",
" (taylor r) (C x) = C x",
" taylor 0 = LinearMap.id",
" ((taylor 0 ∘ₗ monomial n✝¹) 1).coeff n✝ = ((LinearMap.id ∘ₗ mono... |
import Mathlib.Data.List.Basic
#align_import data.list.lattice from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
open Nat
namespace List
variable {α : Type*} {l l₁ l₂ : List α} {p : α → Prop} {a : α}
variable [DecidableEq α]
section BagInter
@[simp]
theorem nil_bagInt... | Mathlib/Data/List/Lattice.lean | 203 | 207 | theorem cons_bagInter_of_pos (l₁ : List α) (h : a ∈ l₂) :
(a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a) := by |
cases l₂
· exact if_pos h
· simp only [List.bagInter, if_pos (elem_eq_true_of_mem h)]
| [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []",
" l.bagInter [] = []",
" (head✝ :: tail✝).bagInter [] = []",
" (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)",
" (a :: l₁).bagInter [] = a :: l₁.bagInter ([].erase a)",
" (a :: l₁).bagInter (head✝ :: tail✝) = ... | [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []",
" l.bagInter [] = []",
" (head✝ :: tail✝).bagInter [] = []",
" (a :: l₁).bagInter l₂ = a :: l₁.bagInter (l₂.erase a)"
] |
import Mathlib.Data.DFinsupp.Lex
import Mathlib.Order.GameAdd
import Mathlib.Order.Antisymmetrization
import Mathlib.SetTheory.Ordinal.Basic
import Mathlib.Tactic.AdaptationNote
#align_import data.dfinsupp.well_founded from "leanprover-community/mathlib"@"e9b8651eb1ad354f4de6be35a38ef31efcd2cfaa"
variable {ι : Ty... | Mathlib/Data/DFinsupp/WellFounded.lean | 103 | 109 | theorem Lex.acc_of_single_erase [DecidableEq ι] {x : Π₀ i, α i} (i : ι)
(hs : Acc (DFinsupp.Lex r s) <| single i (x i)) (hu : Acc (DFinsupp.Lex r s) <| x.erase i) :
Acc (DFinsupp.Lex r s) x := by |
classical
convert ← @Acc.of_fibration _ _ _ _ _ (lex_fibration r s) ⟨{i}, _⟩
(InvImage.accessible snd <| hs.prod_gameAdd hu)
convert piecewise_single_erase x i
| [
" Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s) fun x =>\n x.2.1.piecewise x.2.2 x.1",
" ∃ a',\n InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd a' (p, x₁, x₂) ∧\n (fun x => x.2.1.piecewise x.2.2 x.1) a' = x",
" (x₁.piecewise x {j | r j i}) j... | [
" Fibration (InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd) (DFinsupp.Lex r s) fun x =>\n x.2.1.piecewise x.2.2 x.1",
" ∃ a',\n InvImage (GameAdd (DFinsupp.Lex r s) (DFinsupp.Lex r s)) snd a' (p, x₁, x₂) ∧\n (fun x => x.2.1.piecewise x.2.2 x.1) a' = x",
" (x₁.piecewise x {j | r j i}) j... |
import Mathlib.Topology.CompactOpen
import Mathlib.Topology.Sets.Closeds
open Function Set Filter TopologicalSpace
open scoped Topology
variable {X Y : Type*} [TopologicalSpace X] [TopologicalSpace Y] [CompactSpace Y]
theorem TopologicalSpace.Clopens.exists_prod_subset (W : Clopens (X × Y)) {a : X × Y} (h : a ∈ W... | Mathlib/Topology/ClopenBox.lean | 50 | 61 | theorem TopologicalSpace.Clopens.exists_finset_eq_sup_prod (W : Clopens (X × Y)) :
∃ (I : Finset (Clopens X × Clopens Y)), W = I.sup fun i ↦ i.1 ×ˢ i.2 := by |
choose! U hxU V hxV hUV using fun x ↦ W.exists_prod_subset (a := x)
rcases W.2.1.isCompact.elim_nhds_subcover (fun x ↦ U x ×ˢ V x) (fun x hx ↦
(U x ×ˢ V x).2.isOpen.mem_nhds ⟨hxU x hx, hxV x hx⟩) with ⟨I, hIW, hWI⟩
classical
use I.image fun x ↦ (U x, V x)
rw [Finset.sup_image]
refine le_antisymm (fun x... | [
" ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W",
" a.1 ∈ { carrier := U, isClopen' := ⋯ }",
" ∃ I, W = I.sup fun i => i.1 ×ˢ i.2",
" W = (Finset.image (fun x => (U x, V x)) I).sup fun i => i.1 ×ˢ i.2",
" W = I.sup ((fun i => i.1 ×ˢ i.2) ∘ fun x => (U x, V x))",
" x ∈ ↑(I.sup ((fun i => i.1 ×ˢ i.2) ∘ fun x => ... | [
" ∃ U, a.1 ∈ U ∧ ∃ V, a.2 ∈ V ∧ U ×ˢ V ≤ W",
" a.1 ∈ { carrier := U, isClopen' := ⋯ }",
" ∃ I, W = I.sup fun i => i.1 ×ˢ i.2"
] |
import Mathlib.Data.W.Basic
#align_import data.pfunctor.univariate.basic from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
-- "W", "Idx"
set_option linter.uppercaseLean3 false
universe u v v₁ v₂ v₃
@[pp_with_univ]
structure PFunctor where
A : Type u
B : A → Type u
#align p... | Mathlib/Data/PFunctor/Univariate/Basic.lean | 125 | 125 | theorem W.dest_mk (p : P (W P)) : W.dest (W.mk p) = p := by | cases p; rfl
| [
" (mk p).dest = p",
" (mk ⟨fst✝, snd✝⟩).dest = ⟨fst✝, snd✝⟩"
] | [
" (mk p).dest = p"
] |
import Mathlib.Data.Part
import Mathlib.Data.Nat.Upto
import Mathlib.Data.Stream.Defs
import Mathlib.Tactic.Common
#align_import control.fix from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u v
open scoped Classical
variable {α : Type*} {β : α → Type*}
class Fix (α : Typ... | Mathlib/Control/Fix.lean | 111 | 113 | theorem fix_def' {x : α} (h' : ¬∃ i, (Fix.approx f i x).Dom) : Part.fix f x = none := by |
dsimp [Part.fix]
rw [assert_neg h']
| [
" Part.fix f x = Fix.approx f (Nat.find h').succ x",
" Part.fix f x = Fix.approx f k.succ x",
" Nat.find h' = k + ↑Upto.zero → Part.fix f x = Fix.approx f k.succ x",
" Nat.find h' = k + ↑Upto.zero →\n (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = Fix.approx f (k + 1) x",
... | [
" Part.fix f x = Fix.approx f (Nat.find h').succ x",
" Part.fix f x = Fix.approx f k.succ x",
" Nat.find h' = k + ↑Upto.zero → Part.fix f x = Fix.approx f k.succ x",
" Nat.find h' = k + ↑Upto.zero →\n (assert (∃ i, (Fix.approx f i x).Dom) fun h => ⋯.fix (fixAux f) Upto.zero x) = Fix.approx f (k + 1) x",
... |
import Mathlib.Algebra.Group.Nat
set_option autoImplicit true
open Lean hiding Literal HashMap
open Batteries
namespace Sat
inductive Literal
| pos : Nat → Literal
| neg : Nat → Literal
def Literal.ofInt (i : Int) : Literal :=
if i < 0 then Literal.neg (-i-1).toNat else Literal.pos (i-1).toNat
def Lit... | Mathlib/Tactic/Sat/FromLRAT.lean | 180 | 185 | theorem Fmla.reify_or (h₁ : Fmla.reify v f₁ a) (h₂ : Fmla.reify v f₂ b) :
Fmla.reify v (f₁.and f₂) (a ∨ b) := by |
refine ⟨fun H ↦ by_contra fun hn ↦ H ⟨fun c h ↦ by_contra fun hn' ↦ ?_⟩⟩
rcases List.mem_append.1 h with h | h
· exact hn <| Or.inl <| h₁.1 fun Hc ↦ hn' <| Hc.1 _ h
· exact hn <| Or.inr <| h₂.1 fun Hc ↦ hn' <| Hc.1 _ h
| [
" as = as₁.reverseAux ps → (mk as).implies p ps as₁.length → p",
" as = as₁.reverseAux [] → (mk as).implies p [] as₁.length → p",
" as✝ = as₁.reverseAux (a :: as) → (mk as✝).implies p (a :: as) as₁.length → p",
" mk as✝ as₁.length ↔ a",
" mk (as₁.reverseAux (a :: as)) as₁.length ↔ a",
" ∀ (n n' : ℕ), n' =... | [
" as = as₁.reverseAux ps → (mk as).implies p ps as₁.length → p",
" as = as₁.reverseAux [] → (mk as).implies p [] as₁.length → p",
" as✝ = as₁.reverseAux (a :: as) → (mk as✝).implies p (a :: as) as₁.length → p",
" mk as✝ as₁.length ↔ a",
" mk (as₁.reverseAux (a :: as)) as₁.length ↔ a",
" ∀ (n n' : ℕ), n' =... |
import Mathlib.LinearAlgebra.Dimension.Constructions
import Mathlib.LinearAlgebra.Dimension.Finite
universe u v
open Function Set Cardinal
variable {R} {M M₁ M₂ M₃ : Type u} {M' : Type v} [Ring R]
variable [AddCommGroup M] [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃] [AddCommGroup M']
variable [Module R M... | Mathlib/LinearAlgebra/Dimension/RankNullity.lean | 68 | 72 | theorem lift_rank_range_add_rank_ker (f : M →ₗ[R] M') :
lift.{u} (Module.rank R (LinearMap.range f)) + lift.{v} (Module.rank R (LinearMap.ker f)) =
lift.{v} (Module.rank R M) := by |
haveI := fun p : Submodule R M => Classical.decEq (M ⧸ p)
rw [← f.quotKerEquivRange.lift_rank_eq, ← lift_add, rank_quotient_add_rank]
| [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R ↥(LinearMap.range f)) + lift.{v, u} (Module.rank R ↥(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)"
] | [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R ↥(LinearMap.range f)) + lift.{v, u} (Module.rank R ↥(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)"
] |
import Mathlib.Data.Rat.Cast.Defs
import Mathlib.Algebra.Field.Basic
#align_import data.rat.cast from "leanprover-community/mathlib"@"acebd8d49928f6ed8920e502a6c90674e75bd441"
namespace NNRat
@[simp, norm_cast]
| Mathlib/Data/Rat/Cast/Lemmas.lean | 64 | 67 | theorem cast_pow {K} [DivisionSemiring K] (q : ℚ≥0) (n : ℕ) :
NNRat.cast (q ^ n) = (NNRat.cast q : K) ^ n := by |
rw [cast_def, cast_def, den_pow, num_pow, Nat.cast_pow, Nat.cast_pow, div_eq_mul_inv, ← inv_pow,
← (Nat.cast_commute _ _).mul_pow, ← div_eq_mul_inv]
| [
" ↑(q ^ n) = ↑q ^ n"
] | [
" ↑(q ^ n) = ↑q ^ n"
] |
import Mathlib.Data.Finsupp.Multiset
import Mathlib.Order.Bounded
import Mathlib.SetTheory.Cardinal.PartENat
import Mathlib.SetTheory.Ordinal.Principal
import Mathlib.Tactic.Linarith
#align_import set_theory.cardinal.ordinal from "leanprover-community/mathlib"@"7c2ce0c2da15516b4e65d0c9e254bb6dc93abd1f"
noncomputa... | Mathlib/SetTheory/Cardinal/Ordinal.lean | 61 | 70 | theorem ord_isLimit {c} (co : ℵ₀ ≤ c) : (ord c).IsLimit := by |
refine ⟨fun h => aleph0_ne_zero ?_, fun a => lt_imp_lt_of_le_imp_le fun h => ?_⟩
· rw [← Ordinal.le_zero, ord_le] at h
simpa only [card_zero, nonpos_iff_eq_zero] using co.trans h
· rw [ord_le] at h ⊢
rwa [← @add_one_of_aleph0_le (card a), ← card_succ]
rw [← ord_le, ← le_succ_of_isLimit, ord_le]
·... | [
" c.ord.IsLimit",
" ℵ₀ = 0",
" c.ord ≤ a",
" c ≤ a.card",
" ℵ₀ ≤ a.card",
" ℵ₀ ≤ (succ a).card",
" ℵ₀.ord.IsLimit",
" ω.IsLimit"
] | [
" c.ord.IsLimit"
] |
import Mathlib.Control.Bitraversable.Basic
#align_import control.bitraversable.lemmas from "leanprover-community/mathlib"@"58581d0fe523063f5651df0619be2bf65012a94a"
universe u
variable {t : Type u → Type u → Type u} [Bitraversable t]
variable {β : Type u}
namespace Bitraversable
open Functor LawfulApplicative
... | Mathlib/Control/Bitraversable/Lemmas.lean | 116 | 118 | theorem tsnd_eq_snd_id {α β β'} (f : β → β') (x : t α β) :
tsnd (F := Id) (pure ∘ f) x = pure (snd f x) := by |
apply bitraverse_eq_bimap_id
| [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... | [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... |
import Mathlib.Topology.Algebra.Group.Basic
import Mathlib.Topology.Order.LeftRightNhds
#align_import topology.algebra.order.group from "leanprover-community/mathlib"@"84dc0bd6619acaea625086d6f53cb35cdd554219"
open Set Filter
open Topology Filter
variable {α G : Type*} [TopologicalSpace G] [LinearOrderedAddComm... | Mathlib/Topology/Algebra/Order/Group.lean | 67 | 73 | theorem tendsto_zero_iff_abs_tendsto_zero (f : α → G) :
Tendsto f l (𝓝 0) ↔ Tendsto (abs ∘ f) l (𝓝 0) := by |
refine ⟨fun h => (abs_zero : |(0 : G)| = 0) ▸ h.abs, fun h => ?_⟩
have : Tendsto (fun a => -|f a|) l (𝓝 0) := (neg_zero : -(0 : G) = 0) ▸ h.neg
exact
tendsto_of_tendsto_of_tendsto_of_le_of_le this h (fun x => neg_abs_le <| f x) fun x =>
le_abs_self <| f x
| [
" Continuous fun p => p.1 + p.2",
" ∀ (x : G × G), ContinuousAt (fun p => p.1 + p.2) x",
" ContinuousAt (fun p => p.1 + p.2) (a, b)",
" ∀ᶠ (b_1 : G × G) in 𝓝 (a, b), |b_1.1 + b_1.2 - (fun p => p.1 + p.2) (a, b)| < ε",
" ∀ (a_1 : G × G), |a_1.1 - a| < δ ∧ |a_1.2 - b| < ε - δ → |a_1.1 + a_1.2 - (a + b)| < ε"... | [
" Continuous fun p => p.1 + p.2",
" ∀ (x : G × G), ContinuousAt (fun p => p.1 + p.2) x",
" ContinuousAt (fun p => p.1 + p.2) (a, b)",
" ∀ᶠ (b_1 : G × G) in 𝓝 (a, b), |b_1.1 + b_1.2 - (fun p => p.1 + p.2) (a, b)| < ε",
" ∀ (a_1 : G × G), |a_1.1 - a| < δ ∧ |a_1.2 - b| < ε - δ → |a_1.1 + a_1.2 - (a + b)| < ε"... |
import Mathlib.RingTheory.Ideal.Basic
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.RingTheory.GradedAlgebra.Basic
#align_import ring_theory.graded_algebra.homogeneous_ideal from "leanprover-community/mathlib"@"4e861f25ba5ceef42ba0712d8ffeb32f38ad6441"
open SetLike Direc... | Mathlib/RingTheory/GradedAlgebra/HomogeneousIdeal.lean | 64 | 69 | theorem Ideal.IsHomogeneous.mem_iff {I} (hI : Ideal.IsHomogeneous 𝒜 I) {x} :
x ∈ I ↔ ∀ i, (decompose 𝒜 x i : A) ∈ I := by |
classical
refine ⟨fun hx i ↦ hI i hx, fun hx ↦ ?_⟩
rw [← DirectSum.sum_support_decompose 𝒜 x]
exact Ideal.sum_mem _ (fun i _ ↦ hx i)
| [
" x ∈ I ↔ ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I",
" x ∈ I",
" ∑ i ∈ DFinsupp.support ((decompose 𝒜) x), ↑(((decompose 𝒜) x) i) ∈ I"
] | [
" x ∈ I ↔ ∀ (i : ι), ↑(((decompose 𝒜) x) i) ∈ I"
] |
import Mathlib.Logic.Function.Basic
import Mathlib.Logic.Relator
import Mathlib.Init.Data.Quot
import Mathlib.Tactic.Cases
import Mathlib.Tactic.Use
import Mathlib.Tactic.MkIffOfInductiveProp
import Mathlib.Tactic.SimpRw
#align_import logic.relation from "leanprover-community/mathlib"@"3365b20c2ffa7c35e47e5209b89ba9a... | Mathlib/Logic/Relation.lean | 324 | 332 | theorem head_induction_on {P : ∀ a : α, ReflTransGen r a b → Prop} {a : α} (h : ReflTransGen r a b)
(refl : P b refl)
(head : ∀ {a c} (h' : r a c) (h : ReflTransGen r c b), P c h → P a (h.head h')) : P a h := by |
induction h with
| refl => exact refl
| @tail b c _ hbc ih =>
apply ih
· exact head hbc _ refl
· exact fun h1 h2 ↦ head h1 (h2.tail hbc)
| [
" ReflTransGen r a c",
" ReflTransGen r a b",
" ReflTransGen r a c✝",
" Symmetric (ReflTransGen r)",
" ReflTransGen r y x",
" ReflTransGen r x x",
" ReflTransGen r w x",
" P a h",
" P a ⋯",
" P b ⋯",
" ∀ {a c_1 : α} (h' : r a c_1) (h : ReflTransGen r c_1 b), P c_1 ⋯ → P a ⋯"
] | [
" ReflTransGen r a c",
" ReflTransGen r a b",
" ReflTransGen r a c✝",
" Symmetric (ReflTransGen r)",
" ReflTransGen r y x",
" ReflTransGen r x x",
" ReflTransGen r w x",
" P a h"
] |
import Mathlib.LinearAlgebra.Dimension.Constructions
import Mathlib.LinearAlgebra.Dimension.Finite
universe u v
open Function Set Cardinal
variable {R} {M M₁ M₂ M₃ : Type u} {M' : Type v} [Ring R]
variable [AddCommGroup M] [AddCommGroup M₁] [AddCommGroup M₂] [AddCommGroup M₃] [AddCommGroup M']
variable [Module R M... | Mathlib/LinearAlgebra/Dimension/RankNullity.lean | 91 | 109 | theorem exists_linearIndependent_of_lt_rank [StrongRankCondition R]
{s : Set M} (hs : LinearIndependent (ι := s) R Subtype.val) :
∃ t, s ⊆ t ∧ #t = Module.rank R M ∧ LinearIndependent (ι := t) R Subtype.val := by |
obtain ⟨t, ht, ht'⟩ := exists_set_linearIndependent R (M ⧸ Submodule.span R s)
choose sec hsec using Submodule.Quotient.mk_surjective (Submodule.span R s)
have hsec' : Submodule.Quotient.mk ∘ sec = id := funext hsec
have hst : Disjoint s (sec '' t) := by
rw [Set.disjoint_iff]
rintro _ ⟨hxs, ⟨x, hxt, rf... | [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R ↥(LinearMap.range f)) + lift.{v, u} (Module.rank R ↥(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)",
" Module.rank R ↥(LinearMap.range f) + Module.rank R ↥(LinearMap.ker f) = Module.rank R M",
" lift.{v, u} (Module.rank R M) = lift.{u, v} (Mod... | [
" Nontrivial R",
" False",
" lift.{u, v} (Module.rank R ↥(LinearMap.range f)) + lift.{v, u} (Module.rank R ↥(LinearMap.ker f)) =\n lift.{v, u} (Module.rank R M)",
" Module.rank R ↥(LinearMap.range f) + Module.rank R ↥(LinearMap.ker f) = Module.rank R M",
" lift.{v, u} (Module.rank R M) = lift.{u, v} (Mod... |
import Mathlib.Algebra.Group.Units
import Mathlib.Algebra.GroupWithZero.Basic
import Mathlib.Logic.Equiv.Defs
import Mathlib.Tactic.Contrapose
import Mathlib.Tactic.Nontriviality
import Mathlib.Tactic.Spread
import Mathlib.Util.AssertExists
#align_import algebra.group_with_zero.units.basic from "leanprover-community/... | Mathlib/Algebra/GroupWithZero/Units/Basic.lean | 113 | 115 | theorem inverse_mul_cancel (x : M₀) (h : IsUnit x) : inverse x * x = 1 := by |
rcases h with ⟨u, rfl⟩
rw [inverse_unit, Units.inv_mul]
| [
" 0 = 1",
" inverse ↑u = ↑u⁻¹",
" x * inverse x = 1",
" ↑u * inverse ↑u = 1",
" inverse x * x = 1",
" inverse ↑u * ↑u = 1"
] | [
" 0 = 1",
" inverse ↑u = ↑u⁻¹",
" x * inverse x = 1",
" ↑u * inverse ↑u = 1",
" inverse x * x = 1"
] |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
#align_import analysis.special_functions.complex.arg from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Filter Metric Set
open scoped ComplexConjugate Real To... | Mathlib/Analysis/SpecialFunctions/Complex/Arg.lean | 54 | 58 | theorem abs_mul_exp_arg_mul_I (x : ℂ) : ↑(abs x) * exp (arg x * I) = x := by |
rcases eq_or_ne x 0 with (rfl | hx)
· simp
· have : abs x ≠ 0 := abs.ne_zero hx
apply Complex.ext <;> field_simp [sin_arg, cos_arg hx, this, mul_comm (abs x)]
| [
" x.arg.sin = x.im / abs x",
" (if 0 ≤ x.re then (x.im / abs x).arcsin\n else if 0 ≤ x.im then ((-x).im / abs x).arcsin + π else ((-x).im / abs x).arcsin - π).sin =\n x.im / abs x",
" (x.im / abs x).arcsin.sin = x.im / abs x",
" (((-x).im / abs x).arcsin + π).sin = x.im / abs x",
" (((-x).im / abs x... | [
" x.arg.sin = x.im / abs x",
" (if 0 ≤ x.re then (x.im / abs x).arcsin\n else if 0 ≤ x.im then ((-x).im / abs x).arcsin + π else ((-x).im / abs x).arcsin - π).sin =\n x.im / abs x",
" (x.im / abs x).arcsin.sin = x.im / abs x",
" (((-x).im / abs x).arcsin + π).sin = x.im / abs x",
" (((-x).im / abs x... |
import Mathlib.Data.Set.Image
import Mathlib.Data.SProd
#align_import data.set.prod from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
open Function
namespace Set
section Prod
variable {α β γ δ : Type*} {s s₁ s₂ : Set α} {t t₁ t₂ : Set β} {a : α} {b : β}
theorem Subsingleton.pro... | Mathlib/Data/Set/Prod.lean | 117 | 119 | theorem prod_singleton : s ×ˢ ({b} : Set β) = (fun a => (a, b)) '' s := by |
ext ⟨x, y⟩
simp [and_left_comm, eq_comm]
| [
" (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)",
" s ×ˢ ∅ = ∅",
" x✝ ∈ s ×ˢ ∅ ↔ x✝ ∈ ∅",
" ∅ ×ˢ t = ∅",
" x✝ ∈ ∅ ×ˢ t ↔ x✝ ∈ ∅",
" univ ×ˢ univ = univ",
" x✝ ∈ univ ×ˢ univ ↔ x✝ ∈ univ",
" univ ×ˢ t = Prod.snd ⁻¹' t",
" s ×ˢ univ = Prod.fst ⁻¹' s",
" s ×ˢ t = univ ↔ s = univ ∧ t = univ",
" {... | [
" (∃ x ∈ s ×ˢ t, p x) ↔ ∃ x ∈ s, ∃ y ∈ t, p (x, y)",
" s ×ˢ ∅ = ∅",
" x✝ ∈ s ×ˢ ∅ ↔ x✝ ∈ ∅",
" ∅ ×ˢ t = ∅",
" x✝ ∈ ∅ ×ˢ t ↔ x✝ ∈ ∅",
" univ ×ˢ univ = univ",
" x✝ ∈ univ ×ˢ univ ↔ x✝ ∈ univ",
" univ ×ˢ t = Prod.snd ⁻¹' t",
" s ×ˢ univ = Prod.fst ⁻¹' s",
" s ×ˢ t = univ ↔ s = univ ∧ t = univ",
" {... |
import Mathlib.Analysis.Analytic.Composition
import Mathlib.Analysis.Analytic.Constructions
import Mathlib.Analysis.Complex.CauchyIntegral
import Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv
open Complex Set
open scoped Topology
variable {E : Type} [NormedAddCommGroup E] [NormedSpace ℂ E]
variable {f g : E →... | Mathlib/Analysis/SpecialFunctions/Complex/Analytic.lean | 57 | 64 | theorem AnalyticAt.cpow (fa : AnalyticAt ℂ f x) (ga : AnalyticAt ℂ g x)
(m : f x ∈ slitPlane) : AnalyticAt ℂ (fun z ↦ f z ^ g z) x := by |
have e : (fun z ↦ f z ^ g z) =ᶠ[𝓝 x] fun z ↦ exp (log (f z) * g z) := by
filter_upwards [(fa.continuousAt.eventually_ne (slitPlane_ne_zero m))]
intro z fz
simp only [fz, cpow_def, if_false]
rw [analyticAt_congr e]
exact ((fa.clog m).mul ga).cexp
| [
" AnalyticOn ℂ cexp univ",
" Differentiable ℂ cexp",
" AnalyticAt ℂ log z",
" ∀ᶠ (z : ℂ) in 𝓝 z, DifferentiableAt ℂ log z",
" ∀ a ∈ slitPlane, DifferentiableAt ℂ log a",
" DifferentiableAt ℂ log z",
" AnalyticAt ℂ (fun z => f z ^ g z) x",
" (fun z => f z ^ g z) =ᶠ[𝓝 x] fun z => cexp ((f z).log * g z... | [
" AnalyticOn ℂ cexp univ",
" Differentiable ℂ cexp",
" AnalyticAt ℂ log z",
" ∀ᶠ (z : ℂ) in 𝓝 z, DifferentiableAt ℂ log z",
" ∀ a ∈ slitPlane, DifferentiableAt ℂ log a",
" DifferentiableAt ℂ log z",
" AnalyticAt ℂ (fun z => f z ^ g z) x"
] |
import Mathlib.Analysis.Seminorm
import Mathlib.Topology.Algebra.Equicontinuity
import Mathlib.Topology.MetricSpace.Equicontinuity
import Mathlib.Topology.Algebra.FilterBasis
import Mathlib.Topology.Algebra.Module.LocallyConvex
#align_import analysis.locally_convex.with_seminorms from "leanprover-community/mathlib"@"... | Mathlib/Analysis/LocallyConvex/WithSeminorms.lean | 902 | 906 | theorem SeminormFamily.finset_sup_comp (q : SeminormFamily 𝕜₂ F ι) (s : Finset ι)
(f : E →ₛₗ[σ₁₂] F) : (s.sup q).comp f = s.sup (q.comp f) := by |
ext x
rw [Seminorm.comp_apply, Seminorm.finset_sup_apply, Seminorm.finset_sup_apply]
rfl
| [
" (s.sup q).comp f = s.sup (q.comp f)",
" ((s.sup q).comp f) x = (s.sup (q.comp f)) x",
" ↑(s.sup fun i => ⟨(q i) (f x), ⋯⟩) = ↑(s.sup fun i => ⟨(q.comp f i) x, ⋯⟩)"
] | [
" (s.sup q).comp f = s.sup (q.comp f)"
] |
import Mathlib.Algebra.Homology.Exact
import Mathlib.CategoryTheory.Limits.Shapes.Biproducts
import Mathlib.CategoryTheory.Adjunction.Limits
import Mathlib.CategoryTheory.Limits.Preserves.Finite
#align_import category_theory.preadditive.projective from "leanprover-community/mathlib"@"3974a774a707e2e06046a14c0eaef4654... | Mathlib/CategoryTheory/Preadditive/Projective.lean | 208 | 214 | theorem map_projective (adj : F ⊣ G) [G.PreservesEpimorphisms] (P : C) (hP : Projective P) :
Projective (F.obj P) where
factors f g _ := by |
rcases hP.factors (adj.unit.app P ≫ G.map f) (G.map g) with ⟨f', hf'⟩
use F.map f' ≫ adj.counit.app _
rw [Category.assoc, ← Adjunction.counit_naturality, ← Category.assoc, ← F.map_comp, hf']
simp
| [
" (i.inv ≫ f') ≫ e = f",
" coprod.desc (factorThru (coprod.inl ≫ f) e) (factorThru (coprod.inr ≫ f) e) ≫ e = f",
" (Sigma.desc fun b => factorThru (Sigma.ι g b ≫ f) e) ≫ e = f",
" biprod.desc (factorThru (biprod.inl ≫ f) e) (factorThru (biprod.inr ≫ f) e) ≫ e = f",
" (biproduct.desc fun b => factorThru (bip... | [
" (i.inv ≫ f') ≫ e = f",
" coprod.desc (factorThru (coprod.inl ≫ f) e) (factorThru (coprod.inr ≫ f) e) ≫ e = f",
" (Sigma.desc fun b => factorThru (Sigma.ι g b ≫ f) e) ≫ e = f",
" biprod.desc (factorThru (biprod.inl ≫ f) e) (factorThru (biprod.inr ≫ f) e) ≫ e = f",
" (biproduct.desc fun b => factorThru (bip... |
import Mathlib.RingTheory.Polynomial.Cyclotomic.Eval
#align_import number_theory.primes_congruent_one from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
namespace Nat
open Polynomial Nat Filter
open scoped Nat
| Mathlib/NumberTheory/PrimesCongruentOne.lean | 26 | 57 | theorem exists_prime_gt_modEq_one {k : ℕ} (n : ℕ) (hk0 : k ≠ 0) :
∃ p : ℕ, Nat.Prime p ∧ n < p ∧ p ≡ 1 [MOD k] := by |
rcases (one_le_iff_ne_zero.2 hk0).eq_or_lt with (rfl | hk1)
· rcases exists_infinite_primes (n + 1) with ⟨p, hnp, hp⟩
exact ⟨p, hp, hnp, modEq_one⟩
let b := k * (n !)
have hgt : 1 < (eval (↑b) (cyclotomic k ℤ)).natAbs := by
rcases le_iff_exists_add'.1 hk1.le with ⟨k, rfl⟩
have hb : 2 ≤ b := le_mul_... | [
" ∃ p, p.Prime ∧ n < p ∧ p ≡ 1 [MOD k]",
" ∃ p, p.Prime ∧ n < p ∧ p ≡ 1 [MOD 1]",
" 1 < (eval (↑b) (cyclotomic k ℤ)).natAbs",
" 1 < (eval (↑b) (cyclotomic (k + 1) ℤ)).natAbs",
" (cyclotomic k (ZMod p)).IsRoot ((castRingHom (ZMod p)) b)",
" ↑↑b = (Int.castRingHom (ZMod p)) ↑b",
" ↑p ∣ eval (↑b) (cyclotom... | [
" ∃ p, p.Prime ∧ n < p ∧ p ≡ 1 [MOD k]"
] |
import Mathlib.Algebra.CharP.Defs
import Mathlib.Algebra.MvPolynomial.Degrees
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.LinearAlgebra.FinsuppVectorSpace
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
#align_import ring_theory.mv_polynomial.basic from "leanprover-community/mathlib"@"2f5b500a507... | Mathlib/RingTheory/MvPolynomial/Basic.lean | 113 | 116 | theorem mem_restrictDegree (p : MvPolynomial σ R) (n : ℕ) :
p ∈ restrictDegree σ R n ↔ ∀ s ∈ p.support, ∀ i, (s : σ →₀ ℕ) i ≤ n := by |
rw [restrictDegree, restrictSupport, Finsupp.mem_supported]
rfl
| [
" p ∈ restrictTotalDegree σ R m ↔ p.totalDegree ≤ m",
" p ∈ restrictTotalDegree σ R m ↔ ∀ b ∈ p.support, (b.sum fun x e => e) ≤ m",
" p ∈ restrictDegree σ R n ↔ ∀ s ∈ p.support, ∀ (i : σ), s i ≤ n",
" ↑p.support ⊆ {n_1 | ∀ (i : σ), n_1 i ≤ n} ↔ ∀ s ∈ p.support, ∀ (i : σ), s i ≤ n"
] | [
" p ∈ restrictTotalDegree σ R m ↔ p.totalDegree ≤ m",
" p ∈ restrictTotalDegree σ R m ↔ ∀ b ∈ p.support, (b.sum fun x e => e) ≤ m",
" p ∈ restrictDegree σ R n ↔ ∀ s ∈ p.support, ∀ (i : σ), s i ≤ n"
] |
import Mathlib.Topology.UniformSpace.UniformConvergence
import Mathlib.Topology.UniformSpace.Equicontinuity
import Mathlib.Topology.Separation
import Mathlib.Topology.Support
#align_import topology.uniform_space.compact from "leanprover-community/mathlib"@"735b22f8f9ff9792cf4212d7cb051c4c994bc685"
open scoped Cla... | Mathlib/Topology/UniformSpace/Compact.lean | 51 | 60 | theorem nhdsSet_diagonal_eq_uniformity [CompactSpace α] : 𝓝ˢ (diagonal α) = 𝓤 α := by |
refine nhdsSet_diagonal_le_uniformity.antisymm ?_
have :
(𝓤 (α × α)).HasBasis (fun U => U ∈ 𝓤 α) fun U =>
(fun p : (α × α) × α × α => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' U ×ˢ U := by
rw [uniformity_prod_eq_comap_prod]
exact (𝓤 α).basis_sets.prod_self.comap _
refine (isCompact_diagonal.nhdsSe... | [
" 𝓝ˢ (diagonal α) = 𝓤 α",
" 𝓤 α ≤ 𝓝ˢ (diagonal α)",
" (𝓤 (α × α)).HasBasis (fun U => U ∈ 𝓤 α) fun U => (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) ⁻¹' U ×ˢ U",
" (Filter.comap (fun p => ((p.1.1, p.2.1), p.1.2, p.2.2)) (𝓤 α ×ˢ 𝓤 α)).HasBasis (fun U => U ∈ 𝓤 α) fun U =>\n (fun p => ((p.1.1, p.2.1), p.... | [
" 𝓝ˢ (diagonal α) = 𝓤 α"
] |
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Aut
import Mathlib.Data.ZMod.Defs
import Mathlib.Tactic.Ring
#align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"
open MulOpposite
universe u v
class Shelf (α : Type u) where
act : ... | Mathlib/Algebra/Quandle.lean | 293 | 297 | theorem self_act_invAct_eq {x y : R} : (x ◃ x) ◃⁻¹ y = x ◃⁻¹ y := by |
rw [← left_cancel (x ◃ x)]
rw [right_inv]
rw [self_act_act_eq]
rw [right_inv]
| [
" x ◃ y = x ◃ y' ↔ y = y'",
" x ◃ y = x ◃ y' → y = y'",
" y = y' → x ◃ y = x ◃ y'",
" x ◃ y = x ◃ y",
" x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y'",
" x ◃⁻¹ y = x ◃⁻¹ y' → y = y'",
" y = y' → x ◃⁻¹ y = x ◃⁻¹ y'",
" x ◃⁻¹ y = x ◃⁻¹ y",
" x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z",
" (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z ... | [
" x ◃ y = x ◃ y' ↔ y = y'",
" x ◃ y = x ◃ y' → y = y'",
" y = y' → x ◃ y = x ◃ y'",
" x ◃ y = x ◃ y",
" x ◃⁻¹ y = x ◃⁻¹ y' ↔ y = y'",
" x ◃⁻¹ y = x ◃⁻¹ y' → y = y'",
" y = y' → x ◃⁻¹ y = x ◃⁻¹ y'",
" x ◃⁻¹ y = x ◃⁻¹ y",
" x ◃⁻¹ y ◃⁻¹ z = (x ◃⁻¹ y) ◃⁻¹ x ◃⁻¹ z",
" (x ◃ x ◃⁻¹ y) ◃ x ◃ x ◃⁻¹ y ◃⁻¹ z ... |
import Mathlib.Order.BooleanAlgebra
import Mathlib.Logic.Equiv.Basic
#align_import order.symm_diff from "leanprover-community/mathlib"@"6eb334bd8f3433d5b08ba156b8ec3e6af47e1904"
open Function OrderDual
variable {ι α β : Type*} {π : ι → Type*}
def symmDiff [Sup α] [SDiff α] (a b : α) : α :=
a \ b ⊔ b \ a
#ali... | Mathlib/Order/SymmDiff.lean | 343 | 343 | theorem symmDiff_top' : a ∆ ⊤ = ￢a := by | simp [symmDiff]
| [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ ⊤ = ￢a"
] | [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ ⊤ = ￢a"
] |
import Mathlib.Analysis.SpecialFunctions.Pow.NNReal
#align_import analysis.special_functions.pow.asymptotics from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
set_option linter.uppercaseLean3 false
noncomputable section
open scoped Classical
open Real Topology NNReal ENNReal Filter C... | Mathlib/Analysis/SpecialFunctions/Pow/Asymptotics.lean | 279 | 283 | theorem IsLittleO.rpow (hr : 0 < r) (hg : 0 ≤ᶠ[l] g) (h : f =o[l] g) :
(fun x => f x ^ r) =o[l] fun x => g x ^ r := by |
refine .of_isBigOWith fun c hc ↦ ?_
rw [← rpow_inv_rpow hc.le hr.ne']
refine (h.forall_isBigOWith ?_).rpow ?_ ?_ hg <;> positivity
| [
" IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r",
" ∀ᶠ (x : α) in l, ‖f x ^ r‖ ≤ c ^ r * ‖g x ^ r‖",
" ‖f x ^ r‖ ≤ c ^ r * ‖g x ^ r‖",
" (c * |g x|) ^ r = c ^ r * |g x ^ r|",
" (fun x => f x ^ r) =o[l] fun x => g x ^ r",
" IsBigOWith c l (fun x => f x ^ r) fun x => g x ^ r",
" IsBigOWith ((c ... | [
" IsBigOWith (c ^ r) l (fun x => f x ^ r) fun x => g x ^ r",
" ∀ᶠ (x : α) in l, ‖f x ^ r‖ ≤ c ^ r * ‖g x ^ r‖",
" ‖f x ^ r‖ ≤ c ^ r * ‖g x ^ r‖",
" (c * |g x|) ^ r = c ^ r * |g x ^ r|",
" (fun x => f x ^ r) =o[l] fun x => g x ^ r"
] |
import Mathlib.LinearAlgebra.DirectSum.Finsupp
import Mathlib.LinearAlgebra.FinsuppVectorSpace
#align_import linear_algebra.tensor_product_basis from "leanprover-community/mathlib"@"f784cc6142443d9ee623a20788c282112c322081"
noncomputable section
open Set LinearMap Submodule
section CommSemiring
variable {R : T... | Mathlib/LinearAlgebra/TensorProduct/Basis.lean | 39 | 41 | theorem Basis.tensorProduct_apply (b : Basis ι R M) (c : Basis κ R N) (i : ι) (j : κ) :
Basis.tensorProduct b c (i, j) = b i ⊗ₜ c j := by |
simp [Basis.tensorProduct]
| [
" (b.tensorProduct c) (i, j) = b i ⊗ₜ[R] c j"
] | [
" (b.tensorProduct c) (i, j) = b i ⊗ₜ[R] c j"
] |
import Mathlib.MeasureTheory.Measure.Regular
import Mathlib.MeasureTheory.Function.SimpleFuncDenseLp
import Mathlib.Topology.UrysohnsLemma
import Mathlib.MeasureTheory.Integral.Bochner
#align_import measure_theory.function.continuous_map_dense from "leanprover-community/mathlib"@"e0736bb5b48bdadbca19dbd857e12bee38ccf... | Mathlib/MeasureTheory/Function/ContinuousMapDense.lean | 139 | 188 | theorem Memℒp.exists_hasCompactSupport_snorm_sub_le [WeaklyLocallyCompactSpace α] [μ.Regular]
(hp : p ≠ ∞) {f : α → E} (hf : Memℒp f p μ) {ε : ℝ≥0∞} (hε : ε ≠ 0) :
∃ g : α → E, HasCompactSupport g ∧ snorm (f - g) p μ ≤ ε ∧ Continuous g ∧ Memℒp g p μ := by |
suffices H :
∃ g : α → E, snorm (f - g) p μ ≤ ε ∧ Continuous g ∧ Memℒp g p μ ∧ HasCompactSupport g by
rcases H with ⟨g, hg, g_cont, g_mem, g_support⟩
exact ⟨g, g_support, hg, g_cont, g_mem⟩
-- It suffices to check that the set of functions we consider approximates characteristic
-- functions, is st... | [
" ∃ f,\n Continuous f ∧\n snorm (fun x => f x - s.indicator (fun _y => c) x) p μ ≤ ε ∧\n (∀ (x : α), ‖f x‖ ≤ ‖c‖) ∧ Function.support f ⊆ u ∧ Memℒp f p μ",
" ‖g x‖ = g x",
" ∀ (x : α), ‖g x • c‖ ≤ ‖c‖",
" ‖g x • c‖ ≤ ‖c‖",
" g x * ‖c‖ ≤ ‖c‖",
" g x ≤ 1",
" ∀ (x : α), ‖g x • c - s.indicator... | [
" ∃ f,\n Continuous f ∧\n snorm (fun x => f x - s.indicator (fun _y => c) x) p μ ≤ ε ∧\n (∀ (x : α), ‖f x‖ ≤ ‖c‖) ∧ Function.support f ⊆ u ∧ Memℒp f p μ",
" ‖g x‖ = g x",
" ∀ (x : α), ‖g x • c‖ ≤ ‖c‖",
" ‖g x • c‖ ≤ ‖c‖",
" g x * ‖c‖ ≤ ‖c‖",
" g x ≤ 1",
" ∀ (x : α), ‖g x • c - s.indicator... |
import Mathlib.Algebra.Algebra.RestrictScalars
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.LinearAlgebra.Quotient
import Mathlib.LinearAlgebra.StdBasis
import Mathlib.GroupTheory.Finiteness
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.RingTheory.Nilpotent.Defs
#align_import ring_theory.finit... | Mathlib/RingTheory/Finiteness.lean | 69 | 77 | theorem fg_iff_exists_fin_generating_family {N : Submodule R M} :
N.FG ↔ ∃ (n : ℕ) (s : Fin n → M), span R (range s) = N := by |
rw [fg_def]
constructor
· rintro ⟨S, Sfin, hS⟩
obtain ⟨n, f, rfl⟩ := Sfin.fin_embedding
exact ⟨n, f, hS⟩
· rintro ⟨n, s, hs⟩
exact ⟨range s, finite_range s, hs⟩
| [
" (∃ S, S.Finite ∧ span R S = N) → N.FG",
" (span R t').FG",
" (span R ↑t).FG",
" AddSubmonoid.closure ↑S = P.toAddSubmonoid",
" span ℕ ↑S = P",
" AddSubgroup.closure ↑S = P.toAddSubgroup",
" span ℤ ↑S = P",
" N.FG ↔ ∃ n s, span R (range s) = N",
" (∃ S, S.Finite ∧ span R S = N) ↔ ∃ n s, span R (ran... | [
" (∃ S, S.Finite ∧ span R S = N) → N.FG",
" (span R t').FG",
" (span R ↑t).FG",
" AddSubmonoid.closure ↑S = P.toAddSubmonoid",
" span ℕ ↑S = P",
" AddSubgroup.closure ↑S = P.toAddSubgroup",
" span ℤ ↑S = P",
" N.FG ↔ ∃ n s, span R (range s) = N"
] |
import Mathlib.MeasureTheory.Integral.SetToL1
#align_import measure_theory.integral.bochner from "leanprover-community/mathlib"@"48fb5b5280e7c81672afc9524185ae994553ebf4"
assert_not_exists Differentiable
noncomputable section
open scoped Topology NNReal ENNReal MeasureTheory
open Set Filter TopologicalSpace EN... | Mathlib/MeasureTheory/Integral/Bochner.lean | 274 | 275 | theorem posPart_map_norm (f : α →ₛ ℝ) : (posPart f).map norm = posPart f := by |
ext; rw [map_apply, Real.norm_eq_abs, abs_of_nonneg]; exact le_max_right _ _
| [
" map norm f.posPart = f.posPart",
" ↑(map norm f.posPart) a✝ = ↑f.posPart a✝",
" 0 ≤ ↑f.posPart a✝"
] | [
" map norm f.posPart = f.posPart"
] |
import Mathlib.Analysis.NormedSpace.lpSpace
import Mathlib.Analysis.NormedSpace.PiLp
import Mathlib.Topology.ContinuousFunction.Bounded
#align_import analysis.normed_space.lp_equiv from "leanprover-community/mathlib"@"6afc9b06856ad973f6a2619e3e8a0a8d537a58f2"
open scoped ENNReal
section LpPiLp
set_option linter... | Mathlib/Analysis/NormedSpace/LpEquiv.lean | 54 | 58 | theorem Memℓp.all (f : ∀ i, E i) : Memℓp f p := by |
rcases p.trichotomy with (rfl | rfl | _h)
· exact memℓp_zero_iff.mpr { i : α | f i ≠ 0 }.toFinite
· exact memℓp_infty_iff.mpr (Set.Finite.bddAbove (Set.range fun i : α ↦ ‖f i‖).toFinite)
· cases nonempty_fintype α; exact memℓp_gen ⟨Finset.univ.sum _, hasSum_fintype _⟩
| [
" Memℓp f p",
" Memℓp f 0",
" Memℓp f ⊤"
] | [
" Memℓp f p"
] |
import Mathlib.Order.Filter.Cofinite
#align_import data.analysis.filter from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
open Set Filter
-- Porting note (#11215): TODO write doc strings
structure CFilter (α σ : Type*) [PartialOrder α] where
f : σ → α
pt : σ
inf : σ → σ → σ
... | Mathlib/Data/Analysis/Filter.lean | 74 | 75 | theorem ofEquiv_val (E : σ ≃ τ) (F : CFilter α σ) (a : τ) : F.ofEquiv E a = F (E.symm a) := by |
cases F; rfl
| [
" (fun a => f (E.symm a)) ((fun a b => E (g (E.symm a) (E.symm b))) a b) ≤ (fun a => f (E.symm a)) a",
" (fun a => f (E.symm a)) ((fun a b => E (g (E.symm a) (E.symm b))) a b) ≤ (fun a => f (E.symm a)) b",
" (ofEquiv E F).f a = F.f (E.symm a)",
" (ofEquiv E { f := f✝, pt := pt✝, inf := inf✝, inf_le_left := in... | [
" (fun a => f (E.symm a)) ((fun a b => E (g (E.symm a) (E.symm b))) a b) ≤ (fun a => f (E.symm a)) a",
" (fun a => f (E.symm a)) ((fun a b => E (g (E.symm a) (E.symm b))) a b) ≤ (fun a => f (E.symm a)) b",
" (ofEquiv E F).f a = F.f (E.symm a)"
] |
import Mathlib.FieldTheory.RatFunc.Defs
import Mathlib.RingTheory.EuclideanDomain
import Mathlib.RingTheory.Localization.FractionRing
import Mathlib.RingTheory.Polynomial.Content
#align_import field_theory.ratfunc from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d010e417b10abb1b6"
universe u v
noncompu... | Mathlib/FieldTheory/RatFunc/Basic.lean | 75 | 76 | theorem ofFractionRing_zero : (ofFractionRing 0 : RatFunc K) = 0 := by |
simp only [Zero.zero, OfNat.ofNat, RatFunc.zero]
| [
" { toFractionRing := 0 } = 0"
] | [
" { toFractionRing := 0 } = 0"
] |
import Mathlib.Order.Interval.Set.UnorderedInterval
import Mathlib.Algebra.Order.Interval.Set.Monoid
import Mathlib.Data.Set.Pointwise.Basic
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Algebra.Order.Group.MinMax
#align_import data.set.pointwise.interval from "leanprover-community/mathlib"@"2196ab363eb097c... | Mathlib/Data/Set/Pointwise/Interval.lean | 663 | 664 | theorem preimage_mul_const_Ioo_of_neg (a b : α) {c : α} (h : c < 0) :
(fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c) := by | simp [← Ioi_inter_Iio, h, inter_comm]
| [
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c)"
] | [
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Icc a b = Icc (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioo a b = Ioo (b / c) (a / c)"
] |
import Mathlib.CategoryTheory.Sites.Subsheaf
import Mathlib.CategoryTheory.Sites.CompatibleSheafification
import Mathlib.CategoryTheory.Sites.LocallyInjective
#align_import category_theory.sites.surjective from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe v u w v' u' w'
open ... | Mathlib/CategoryTheory/Sites/LocallySurjective.lean | 65 | 70 | theorem imageSieve_app {F G : Cᵒᵖ ⥤ A} (f : F ⟶ G) {U : C} (s : F.obj (op U)) :
imageSieve f (f.app _ s) = ⊤ := by |
ext V i
simp only [Sieve.top_apply, iff_true_iff, imageSieve_apply]
have := elementwise_of% (f.naturality i.op)
exact ⟨F.map i.op s, this s⟩
| [
" ∀ {Y Z : C} {f_1 : Y ⟶ U},\n (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Y f_1 →\n ∀ (g : Z ⟶ Y), (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Z (g ≫ f_1)",
" ∃ t, (f.app { unop := W }) t = (G.map (j ≫ i).op) s",
" (f.app { unop := W }) ((F.map j.op) t) = (G.map (j ≫ i).op... | [
" ∀ {Y Z : C} {f_1 : Y ⟶ U},\n (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Y f_1 →\n ∀ (g : Z ⟶ Y), (fun V i => ∃ t, (f.app { unop := V }) t = (G.map i.op) s) Z (g ≫ f_1)",
" ∃ t, (f.app { unop := W }) t = (G.map (j ≫ i).op) s",
" (f.app { unop := W }) ((F.map j.op) t) = (G.map (j ≫ i).op... |
import Mathlib.Algebra.Polynomial.Splits
import Mathlib.RingTheory.MvPolynomial.Symmetric
#align_import ring_theory.polynomial.vieta from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
open Polynomial
namespace Multiset
open Polynomial
section Semiring
variable {R : Type*} [CommSemi... | Mathlib/RingTheory/Polynomial/Vieta.lean | 59 | 71 | theorem prod_X_add_C_coeff (s : Multiset R) {k : ℕ} (h : k ≤ Multiset.card s) :
(s.map fun r => X + C r).prod.coeff k = s.esymm (Multiset.card s - k) := by |
convert Polynomial.ext_iff.mp (prod_X_add_C_eq_sum_esymm s) k using 1
simp_rw [finset_sum_coeff, coeff_C_mul_X_pow]
rw [Finset.sum_eq_single_of_mem (Multiset.card s - k) _]
· rw [if_pos (Nat.sub_sub_self h).symm]
· intro j hj1 hj2
suffices k ≠ card s - j by rw [if_neg this]
intro hn
rw [hn, Nat.s... | [
" (map (fun r => X + C r) s).prod = ∑ j ∈ Finset.range (card s + 1), C (s.esymm j) * X ^ (card s - j)",
" ∀ x ∈ range (card s + 1),\n (map ((fun p => (map (fun r => X) p.1).prod * (map (fun r => C r) p.2).prod) ∘ fun t => (s - t, t))\n (powersetCard x s)).sum =\n C (s.esymm x) * X ^ (card s - x)"... | [
" (map (fun r => X + C r) s).prod = ∑ j ∈ Finset.range (card s + 1), C (s.esymm j) * X ^ (card s - j)",
" ∀ x ∈ range (card s + 1),\n (map ((fun p => (map (fun r => X) p.1).prod * (map (fun r => C r) p.2).prod) ∘ fun t => (s - t, t))\n (powersetCard x s)).sum =\n C (s.esymm x) * X ^ (card s - x)"... |
import Mathlib.Analysis.NormedSpace.Multilinear.Basic
import Mathlib.LinearAlgebra.PiTensorProduct
universe uι u𝕜 uE uF
variable {ι : Type uι} [Fintype ι]
variable {𝕜 : Type u𝕜} [NontriviallyNormedField 𝕜]
variable {E : ι → Type uE} [∀ i, SeminormedAddCommGroup (E i)] [∀ i, NormedSpace 𝕜 (E i)]
variable {F : ... | Mathlib/Analysis/NormedSpace/PiTensorProduct/ProjectiveSeminorm.lean | 84 | 90 | theorem bddBelow_projectiveSemiNormAux (x : ⨂[𝕜] i, E i) :
BddBelow (Set.range (fun (p : lifts x) ↦ projectiveSeminormAux p.1)) := by |
existsi 0
rw [mem_lowerBounds]
simp only [Set.mem_range, Subtype.exists, exists_prop, forall_exists_index, and_imp,
forall_apply_eq_imp_iff₂]
exact fun p _ ↦ projectiveSeminormAux_nonneg p
| [
" 0 ≤ projectiveSeminormAux p",
" 0 ≤ (List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p).sum",
" ∀ x ∈ List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p, 0 ≤ x",
" a ∈ List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p → 0 ≤ a",
" ∀ (x : 𝕜) (x_1 : (i : ι) → E i), (x, x_1) ∈ p → ‖x‖ * ∏ x : ι, ‖x_1 x‖ = a → 0 ≤ a",
... | [
" 0 ≤ projectiveSeminormAux p",
" 0 ≤ (List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p).sum",
" ∀ x ∈ List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p, 0 ≤ x",
" a ∈ List.map (fun p => ‖p.1‖ * ∏ x : ι, ‖p.2 x‖) p → 0 ≤ a",
" ∀ (x : 𝕜) (x_1 : (i : ι) → E i), (x, x_1) ∈ p → ‖x‖ * ∏ x : ι, ‖x_1 x‖ = a → 0 ≤ a",
... |
import Mathlib.Data.Finset.Pointwise
#align_import combinatorics.additive.e_transform from "leanprover-community/mathlib"@"207c92594599a06e7c134f8d00a030a83e6c7259"
open MulOpposite
open Pointwise
variable {α : Type*} [DecidableEq α]
namespace Finset
section CommGroup
variable [CommGroup α] (e : α) (x : F... | Mathlib/Combinatorics/Additive/ETransform.lean | 66 | 70 | theorem mulDysonETransform.card :
(mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card := by |
dsimp
rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
card_union_add_card_inter, card_smul_finset]
| [
" (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2",
" e • x.2 * e⁻¹ • x.1 ⊆ x.1 * x.2",
" (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card",
" (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card"
] | [
" (mulDysonETransform e x).1 * (mulDysonETransform e x).2 ⊆ x.1 * x.2",
" e • x.2 * e⁻¹ • x.1 ⊆ x.1 * x.2",
" (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.