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 220 |
|---|---|---|---|---|---|---|---|
import Mathlib.Logic.Relation
import Mathlib.Data.List.Forall2
import Mathlib.Data.List.Lex
import Mathlib.Data.List.Infix
#align_import data.list.chain from "leanprover-community/mathlib"@"dd71334db81d0bd444af1ee339a29298bef40734"
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSu... | Mathlib/Data/List/Chain.lean | 86 | 88 | theorem chain_map (f : β → α) {b : β} {l : List β} :
Chain R (f b) (map f l) ↔ Chain (fun a b : β => R (f a) (f b)) b l := by |
induction l generalizing b <;> simp only [map, Chain.nil, chain_cons, *]
| [
" Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l",
" Chain (fun x y => x ∈ [a✝] ∧ y ∈ [] ∧ R x y) a✝ []",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) a (b :: l)",
" a ∈ a :: b :: l ∧ b ∈ b :: l ∧ R a b",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) b l",
" Chain R a [b] ↔ R a... | [
" Chain (fun x y => x ∈ a :: l ∧ y ∈ l ∧ R x y) a l",
" Chain (fun x y => x ∈ [a✝] ∧ y ∈ [] ∧ R x y) a✝ []",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) a (b :: l)",
" a ∈ a :: b :: l ∧ b ∈ b :: l ∧ R a b",
" Chain (fun x y => x ∈ a :: b :: l ∧ y ∈ b :: l ∧ R x y) b l",
" Chain R a [b] ↔ R a... |
import Mathlib.Algebra.Homology.ExactSequence
import Mathlib.CategoryTheory.Abelian.Refinements
#align_import category_theory.abelian.diagram_lemmas.four from "leanprover-community/mathlib"@"d34cbcf6c94953e965448c933cd9cc485115ebbd"
namespace CategoryTheory
open Category Limits Preadditive
namespace Abelian
va... | Mathlib/CategoryTheory/Abelian/DiagramLemmas/Four.lean | 95 | 120 | theorem epi_of_epi_of_epi_of_mono'
(hR₁ : (mk₂ (R₁.map' 1 2) (R₁.map' 2 3)).Exact)
(hR₂ : (mk₂ (R₂.map' 0 1) (R₂.map' 1 2)).Exact) (hR₂' : R₂.map' 1 3 = 0)
(h₀ : Epi (app' φ 0)) (h₂ : Epi (app' φ 2)) (h₃ : Mono (app' φ 3)) :
Epi (app' φ 1) := by |
rw [epi_iff_surjective_up_to_refinements]
intro A g₁
obtain ⟨A₁, π₁, _, f₂, h₁⟩ :=
surjective_up_to_refinements_of_epi (app' φ 2 _) (g₁ ≫ R₂.map' 1 2)
have h₂ : f₂ ≫ R₁.map' 2 3 = 0 := by
rw [← cancel_mono (app' φ 3 _), assoc, zero_comp, NatTrans.naturality, ← reassoc_of% h₁,
← R₂.map'_comp 1 2 3... | [
" Mono (app' φ 2 ⋯)",
" ∀ {P : C} (g : P ⟶ R₁.obj' 2 ⋯), g ≫ app' φ 2 ⋯ = 0 → g = 0",
" f₂ = 0",
" f₂ ≫ R₁.map' 2 3 ⋯ ⋯ = 0",
" (f₁ ≫ app' φ 1 ⋯) ≫ R₂.map' 1 2 ⋯ ⋯ = 0",
" f₀ ≫ R₁.map' 0 1 ⋯ ⋯ = π₃ ≫ π₂ ≫ f₁",
" π₃ ≫ g₀ ≫ R₂.map (homOfLE ⋯) = π₃ ≫ g₀ ≫ ((mk₂ (R₂.map' 0 1 ⋯ ⋯) (R₂.map' 1 2 ⋯ ⋯)).sc ⋯ 0 ⋯... | [
" Mono (app' φ 2 ⋯)",
" ∀ {P : C} (g : P ⟶ R₁.obj' 2 ⋯), g ≫ app' φ 2 ⋯ = 0 → g = 0",
" f₂ = 0",
" f₂ ≫ R₁.map' 2 3 ⋯ ⋯ = 0",
" (f₁ ≫ app' φ 1 ⋯) ≫ R₂.map' 1 2 ⋯ ⋯ = 0",
" f₀ ≫ R₁.map' 0 1 ⋯ ⋯ = π₃ ≫ π₂ ≫ f₁",
" π₃ ≫ g₀ ≫ R₂.map (homOfLE ⋯) = π₃ ≫ g₀ ≫ ((mk₂ (R₂.map' 0 1 ⋯ ⋯) (R₂.map' 1 2 ⋯ ⋯)).sc ⋯ 0 ⋯... |
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 | 91 | 94 | theorem gold_sq : φ ^ 2 = φ + 1 := by |
rw [goldenRatio, ← 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.Analysis.SpecificLimits.Basic
import Mathlib.Order.Interval.Set.IsoIoo
import Mathlib.Topology.Order.MonotoneContinuity
import Mathlib.Topology.UrysohnsBounded
#align_import topology.tietze_extension from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
section TietzeExten... | Mathlib/Topology/TietzeExtension.lean | 108 | 112 | theorem ContinuousMap.exists_extension_forall_mem {Y : Type v} [TopologicalSpace Y] (f : C(X₁, Y))
{t : Set Y} (hf : ∀ x, f x ∈ t) [ht : TietzeExtension.{u, v} t] :
∃ (g : C(X, Y)), (∀ x, g x ∈ t) ∧ g.comp ⟨e, he.continuous⟩ = f := by |
obtain ⟨g, hg⟩ := mk _ (map_continuous f |>.codRestrict hf) |>.exists_extension he
exact ⟨comp ⟨Subtype.val, by continuity⟩ g, by simp, by ext x; congrm(($(hg) x : Y))⟩
| [
" ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f",
" g.comp { toFun := e, continuous_toFun := ⋯ } = f",
" (g.comp { toFun := e, continuous_toFun := ⋯ }) x = f x",
" ⇑g ∘ e = ⇑f",
" (⇑g ∘ e) x = f x",
" ∃ g, (∀ (x : X), g x ∈ t) ∧ restrict s g = f",
" Continuous Subtype.val",
" ∀ (x : X), ({ toF... | [
" ∃ g, g.comp { toFun := e, continuous_toFun := ⋯ } = f",
" g.comp { toFun := e, continuous_toFun := ⋯ } = f",
" (g.comp { toFun := e, continuous_toFun := ⋯ }) x = f x",
" ⇑g ∘ e = ⇑f",
" (⇑g ∘ e) x = f x",
" ∃ g, (∀ (x : X), g x ∈ t) ∧ restrict s g = f",
" Continuous Subtype.val",
" ∀ (x : X), ({ toF... |
import Mathlib.LinearAlgebra.Matrix.ToLin
import Mathlib.LinearAlgebra.Quotient
import Mathlib.RingTheory.Ideal.Maps
import Mathlib.RingTheory.Nilpotent.Defs
#align_import ring_theory.nilpotent from "leanprover-community/mathlib"@"da420a8c6dd5bdfb85c4ced85c34388f633bc6ff"
universe u v
open Function Set
variable ... | Mathlib/RingTheory/Nilpotent/Lemmas.lean | 123 | 126 | theorem IsNilpotent.mapQ (hnp : IsNilpotent f) : IsNilpotent (p.mapQ p f hp) := by |
obtain ⟨k, hk⟩ := hnp
use k
simp [← p.mapQ_pow, hk]
| [
" (ker f).IsRadical ↔ IsReduced S",
" (ker f).IsRadical ↔ ∀ (x : R), (∃ n, x ^ n ∈ ker f) → x ∈ ker f",
" IsRadical y ↔ (Ideal.span {y}).IsRadical",
" (∀ (n : ℕ) (x : R), x ^ n ∈ Ideal.span {y} → x ∈ Ideal.span {y}) ↔ (Ideal.span {y}).IsRadical",
" IsNilpotent (f.restrict hf)",
" (f.restrict hf ^ n) m = 0... | [
" (ker f).IsRadical ↔ IsReduced S",
" (ker f).IsRadical ↔ ∀ (x : R), (∃ n, x ^ n ∈ ker f) → x ∈ ker f",
" IsRadical y ↔ (Ideal.span {y}).IsRadical",
" (∀ (n : ℕ) (x : R), x ^ n ∈ Ideal.span {y} → x ∈ Ideal.span {y}) ↔ (Ideal.span {y}).IsRadical",
" IsNilpotent (f.restrict hf)",
" (f.restrict hf ^ n) m = 0... |
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Data.Fintype.Fin
import Mathlib.GroupTheory.GroupAction.Pi
import Mathlib.Logic.Equiv.Fin
#align_import algebra.big_operators.fin from "leanprover-community/mathlib"@"cc5dd6244981976cc9da7afc4eee5682b037a013"
open Fins... | Mathlib/Algebra/BigOperators/Fin.lean | 113 | 113 | theorem prod_univ_one [CommMonoid β] (f : Fin 1 → β) : ∏ i, f i = f 0 := by | simp
| [
" (List.ofFn f).prod = ∏ i : Fin n, f i",
" ∏ i : Fin n, f i = (List.map f (List.finRange n)).prod",
" ∏ i : Fin (n + 1), f i = f x * ∏ i : Fin n, f (x.succAbove i)",
" f x * ∏ x_1 : Fin n, f (x.succAboveEmb x_1) = f x * ∏ i : Fin n, f (x.succAbove i)",
" ∏ i : Fin (n + 1), f i = (∏ i : Fin n, f i.castSucc)... | [
" (List.ofFn f).prod = ∏ i : Fin n, f i",
" ∏ i : Fin n, f i = (List.map f (List.finRange n)).prod",
" ∏ i : Fin (n + 1), f i = f x * ∏ i : Fin n, f (x.succAbove i)",
" f x * ∏ x_1 : Fin n, f (x.succAboveEmb x_1) = f x * ∏ i : Fin n, f (x.succAbove i)",
" ∏ i : Fin (n + 1), f i = (∏ i : Fin n, f i.castSucc)... |
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.Asymptotics.Theta
import Mathlib.Analysis.Normed.Order.Basic
#align_import analysis.asymptotics.asymptotic_equivalent from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
namespace Asymptotics
open Filter Function
... | Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean | 89 | 91 | theorem IsEquivalent.isBigO_symm (h : u ~[l] v) : v =O[l] u := by |
convert h.isLittleO.right_isBigO_add
simp
| [
" v =O[l] u",
" u x✝ = (u - v) x✝ + v x✝"
] | [] |
import Mathlib.Analysis.InnerProductSpace.Calculus
import Mathlib.Analysis.InnerProductSpace.Dual
import Mathlib.Analysis.InnerProductSpace.Adjoint
import Mathlib.Analysis.Calculus.LagrangeMultipliers
import Mathlib.LinearAlgebra.Eigenspace.Basic
#align_import analysis.inner_product_space.rayleigh from "leanprover-co... | Mathlib/Analysis/InnerProductSpace/Rayleigh.lean | 107 | 114 | theorem _root_.LinearMap.IsSymmetric.hasStrictFDerivAt_reApplyInnerSelf {T : F →L[ℝ] F}
(hT : (T : F →ₗ[ℝ] F).IsSymmetric) (x₀ : F) :
HasStrictFDerivAt T.reApplyInnerSelf (2 • (innerSL ℝ (T x₀))) x₀ := by |
convert T.hasStrictFDerivAt.inner ℝ (hasStrictFDerivAt_id x₀) using 1
ext y
rw [ContinuousLinearMap.smul_apply, ContinuousLinearMap.comp_apply, fderivInnerCLM_apply,
ContinuousLinearMap.prod_apply, innerSL_apply, id, ContinuousLinearMap.id_apply,
hT.apply_clm x₀ y, real_inner_comm _ x₀, two_smul]
| [
" HasStrictFDerivAt T.reApplyInnerSelf (2 • (innerSL ℝ) (T x₀)) x₀",
" 2 • (innerSL ℝ) (T x₀) = (fderivInnerCLM ℝ (T x₀, id x₀)).comp (T.prod (ContinuousLinearMap.id ℝ F))",
" (2 • (innerSL ℝ) (T x₀)) y = ((fderivInnerCLM ℝ (T x₀, id x₀)).comp (T.prod (ContinuousLinearMap.id ℝ F))) y"
] | [] |
import Mathlib.Algebra.CharP.ExpChar
import Mathlib.GroupTheory.OrderOfElement
#align_import algebra.char_p.two from "leanprover-community/mathlib"@"7f1ba1a333d66eed531ecb4092493cd1b6715450"
variable {R ι : Type*}
namespace CharTwo
section Semiring
variable [Semiring R] [CharP R 2]
theorem two_eq_zero : (2 : ... | Mathlib/Algebra/CharP/Two.lean | 38 | 40 | theorem bit0_eq_zero : (bit0 : R → R) = 0 := by |
funext
exact add_self_eq_zero _
| [
" 2 = 0",
" x + x = 0",
" bit0 = 0",
" bit0 x✝ = 0 x✝"
] | [
" 2 = 0",
" x + x = 0"
] |
import Mathlib.Data.Int.Interval
import Mathlib.Data.Int.SuccPred
import Mathlib.Data.Int.ConditionallyCompleteOrder
import Mathlib.Topology.Instances.Discrete
import Mathlib.Topology.MetricSpace.Bounded
import Mathlib.Order.Filter.Archimedean
#align_import topology.instances.int from "leanprover-community/mathlib"@"... | Mathlib/Topology/Instances/Int.lean | 66 | 67 | theorem closedBall_eq_Icc (x : ℤ) (r : ℝ) : closedBall x r = Icc ⌈↑x - r⌉ ⌊↑x + r⌋ := by |
rw [← preimage_closedBall, Real.closedBall_eq_Icc, preimage_Icc]
| [
" dist m n = ↑|m - n|",
" |↑m - ↑n| = ↑|m - n|",
" Pairwise fun m n => 1 ≤ dist m n",
" 1 ≤ dist m n",
" 1 ≤ |↑m - ↑n|",
" 1 ≤ |m - n|",
" ball x r = Ioo ⌊↑x - r⌋ ⌈↑x + r⌉",
" closedBall x r = Icc ⌈↑x - r⌉ ⌊↑x + r⌋"
] | [
" dist m n = ↑|m - n|",
" |↑m - ↑n| = ↑|m - n|",
" Pairwise fun m n => 1 ≤ dist m n",
" 1 ≤ dist m n",
" 1 ≤ |↑m - ↑n|",
" 1 ≤ |m - n|",
" ball x r = Ioo ⌊↑x - r⌋ ⌈↑x + r⌉"
] |
import Mathlib.Algebra.Group.Basic
import Mathlib.Algebra.Order.Monoid.Canonical.Defs
import Mathlib.Data.Set.Function
import Mathlib.Order.Interval.Set.Basic
#align_import data.set.intervals.monoid from "leanprover-community/mathlib"@"aba57d4d3dae35460225919dcd82fe91355162f9"
namespace Set
variable {M : Type*} ... | Mathlib/Algebra/Order/Interval/Set/Monoid.lean | 44 | 48 | theorem Icc_add_bij : BijOn (· + d) (Icc a b) (Icc (a + d) (b + d)) := by |
rw [← Ici_inter_Iic, ← Ici_inter_Iic]
exact
(Ici_add_bij a d).inter_mapsTo (fun x hx => add_le_add_right hx _) fun x hx =>
le_of_add_le_add_right hx.2
| [
" BijOn (fun x => x + d) (Ici a) (Ici (a + d))",
" x✝ ∈ (fun x => x + d) '' Ici a",
" a + d + c ∈ (fun x => x + d) '' Ici a",
" (fun x => x + d) (a + c) = a + d + c",
" BijOn (fun x => x + d) (Ioi a) (Ioi (a + d))",
" x✝ ∈ (fun x => x + d) '' Ioi a",
" a + d + c ∈ (fun x => x + d) '' Ioi a",
" BijOn (... | [
" BijOn (fun x => x + d) (Ici a) (Ici (a + d))",
" x✝ ∈ (fun x => x + d) '' Ici a",
" a + d + c ∈ (fun x => x + d) '' Ici a",
" (fun x => x + d) (a + c) = a + d + c",
" BijOn (fun x => x + d) (Ioi a) (Ioi (a + d))",
" x✝ ∈ (fun x => x + d) '' Ioi a",
" a + d + c ∈ (fun x => x + d) '' Ioi a"
] |
import Mathlib.MeasureTheory.Function.SimpleFuncDenseLp
#align_import measure_theory.integral.set_to_l1 from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classical Topology NNReal ENNReal MeasureTheory Pointwise
open Set Filter TopologicalSpace ENNR... | Mathlib/MeasureTheory/Integral/SetToL1.lean | 152 | 179 | theorem map_iUnion_fin_meas_set_eq_sum (T : Set α → β) (T_empty : T ∅ = 0)
(h_add : FinMeasAdditive μ T) {ι} (S : ι → Set α) (sι : Finset ι)
(hS_meas : ∀ i, MeasurableSet (S i)) (hSp : ∀ i ∈ sι, μ (S i) ≠ ∞)
(h_disj : ∀ᵉ (i ∈ sι) (j ∈ sι), i ≠ j → Disjoint (S i) (S j)) :
T (⋃ i ∈ sι, S i) = ∑ i ∈ sι, T ... |
revert hSp h_disj
refine Finset.induction_on sι ?_ ?_
· simp only [Finset.not_mem_empty, IsEmpty.forall_iff, iUnion_false, iUnion_empty, sum_empty,
forall₂_true_iff, imp_true_iff, forall_true_left, not_false_iff, T_empty]
intro a s has h hps h_disj
rw [Finset.sum_insert has, ← h]
swap; · exact fun i ... | [
" 0 (s ∪ t) = 0 s + 0 t",
" FinMeasAdditive μ (T + T')",
" (T + T') (s ∪ t) = (T + T') s + (T + T') t",
" T s + T t + (T' s + T' t) = T s + T' s + (T t + T' t)",
" (fun s => c • T s) (s ∪ t) = (fun s => c • T s) s + (fun s => c • T s) t",
" FinMeasAdditive μ T",
" μ s = ⊤",
" FinMeasAdditive (c • μ) T... | [
" 0 (s ∪ t) = 0 s + 0 t",
" FinMeasAdditive μ (T + T')",
" (T + T') (s ∪ t) = (T + T') s + (T + T') t",
" T s + T t + (T' s + T' t) = T s + T' s + (T t + T' t)",
" (fun s => c • T s) (s ∪ t) = (fun s => c • T s) s + (fun s => c • T s) t",
" FinMeasAdditive μ T",
" μ s = ⊤",
" FinMeasAdditive (c • μ) T... |
import Mathlib.Analysis.Calculus.Deriv.Inv
import Mathlib.Analysis.NormedSpace.BallAction
import Mathlib.Analysis.SpecialFunctions.ExpDeriv
import Mathlib.Analysis.InnerProductSpace.Calculus
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.Geometry.Manifold.Algebra.LieGroup
import Mathlib.Geometry.Manifol... | Mathlib/Geometry/Manifold/Instances/Sphere.lean | 131 | 142 | theorem stereoInvFunAux_mem (hv : ‖v‖ = 1) {w : E} (hw : w ∈ (ℝ ∙ v)ᗮ) :
stereoInvFunAux v w ∈ sphere (0 : E) 1 := by |
have h₁ : (0 : ℝ) < ‖w‖ ^ 2 + 4 := by positivity
suffices ‖(4 : ℝ) • w + (‖w‖ ^ 2 - 4) • v‖ = ‖w‖ ^ 2 + 4 by
simp only [mem_sphere_zero_iff_norm, norm_smul, Real.norm_eq_abs, abs_inv, this,
abs_of_pos h₁, stereoInvFunAux_apply, inv_mul_cancel h₁.ne']
suffices ‖(4 : ℝ) • w + (‖w‖ ^ 2 - 4) • v‖ ^ 2 = (‖w... | [
" ContDiffOn ℝ ⊤ (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1}",
" ContDiffOn ℝ ⊤ (fun x => 2 / (1 - ((innerSL ℝ) v) x)) {x | ((innerSL ℝ) v) x ≠ 1}",
" ContDiffOn ℝ ⊤ (fun x => 1 - ((innerSL ℝ) v) x) {x | ((innerSL ℝ) v) x ≠ 1}",
" ∀ x ∈ {x | ((innerSL ℝ) v) x ≠ 1}, 1 - ((innerSL ℝ) v) x ≠ 0",
" False",
" ... | [
" ContDiffOn ℝ ⊤ (stereoToFun v) {x | ((innerSL ℝ) v) x ≠ 1}",
" ContDiffOn ℝ ⊤ (fun x => 2 / (1 - ((innerSL ℝ) v) x)) {x | ((innerSL ℝ) v) x ≠ 1}",
" ContDiffOn ℝ ⊤ (fun x => 1 - ((innerSL ℝ) v) x) {x | ((innerSL ℝ) v) x ≠ 1}",
" ∀ x ∈ {x | ((innerSL ℝ) v) x ≠ 1}, 1 - ((innerSL ℝ) v) x ≠ 0",
" False"
] |
import Mathlib.Data.Matrix.Basic
variable {l m n o : Type*}
universe u v w
variable {R : Type*} {α : Type v} {β : Type w}
namespace Matrix
def col (w : m → α) : Matrix m Unit α :=
of fun x _ => w x
#align matrix.col Matrix.col
-- TODO: set as an equation lemma for `col`, see mathlib4#3024
@[simp]
theorem col... | Mathlib/Data/Matrix/RowCol.lean | 94 | 96 | theorem transpose_col (v : m → α) : (Matrix.col v)ᵀ = Matrix.row v := by |
ext
rfl
| [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝",
" col (x • v) = x • col v",
" col (x • v) i✝ j✝ = (x • col v) i✝ j✝",
" row (v + w) = row v + row w",
" row (v + w) i✝ j✝ = (row v + row w) i✝ j✝",
" row (x • v) = x • row v",
" row (x • v) i✝ j✝ = (x • row v) i✝ j✝",
" (c... | [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝",
" col (x • v) = x • col v",
" col (x • v) i✝ j✝ = (x • col v) i✝ j✝",
" row (v + w) = row v + row w",
" row (v + w) i✝ j✝ = (row v + row w) i✝ j✝",
" row (x • v) = x • row v",
" row (x • v) i✝ j✝ = (x • row v) i✝ j✝"
] |
import Mathlib.Algebra.Polynomial.AlgebraMap
import Mathlib.Algebra.Polynomial.BigOperators
import Mathlib.Algebra.Polynomial.Degree.Lemmas
import Mathlib.Algebra.Polynomial.Div
#align_import data.polynomial.ring_division from "leanprover-community/mathlib"@"8efcf8022aac8e01df8d302dcebdbc25d6a886c8"
noncomputable ... | Mathlib/Algebra/Polynomial/RingDivision.lean | 284 | 291 | theorem Monic.irreducible_iff_lt_natDegree_lt {p : R[X]} (hp : p.Monic) (hp1 : p ≠ 1) :
Irreducible p ↔ ∀ q, Monic q → natDegree q ∈ Finset.Ioc 0 (natDegree p / 2) → ¬ q ∣ p := by |
rw [hp.irreducible_iff_natDegree', and_iff_right hp1]
constructor
· rintro h g hg hdg ⟨f, rfl⟩
exact h f g (hg.of_mul_monic_left hp) hg (mul_comm f g) hdg
· rintro h f g - hg rfl hdg
exact h g hg hdg (dvd_mul_left g f)
| [
" Irreducible p ↔ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f = 1 ∨ g = 1",
" (g * C f.leadingCoeff).Monic",
" (f * C g.leadingCoeff).Monic",
" g * C f.leadingCoeff * (f * C g.leadingCoeff) = p",
" Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = ... | [
" Irreducible p ↔ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f = 1 ∨ g = 1",
" (g * C f.leadingCoeff).Monic",
" (f * C g.leadingCoeff).Monic",
" g * C f.leadingCoeff * (f * C g.leadingCoeff) = p",
" Irreducible p ↔ p ≠ 1 ∧ ∀ (f g : R[X]), f.Monic → g.Monic → f * g = p → f.natDegree = 0 ∨ g.natDegree = ... |
import Mathlib.Analysis.InnerProductSpace.Projection
import Mathlib.MeasureTheory.Function.ConditionalExpectation.Unique
import Mathlib.MeasureTheory.Function.L2Space
#align_import measure_theory.function.conditional_expectation.condexp_L2 from "leanprover-community/mathlib"@"d8bbb04e2d2a44596798a9207ceefc0fb236e41e"... | Mathlib/MeasureTheory/Function/ConditionalExpectation/CondexpL2.lean | 113 | 117 | theorem norm_condexpL2_coe_le (hm : m ≤ m0) (f : α →₂[μ] E) :
‖(condexpL2 E 𝕜 hm f : α →₂[μ] E)‖ ≤ ‖f‖ := by |
rw [Lp.norm_def, Lp.norm_def, ← lpMeas_coe]
refine (ENNReal.toReal_le_toReal ?_ (Lp.snorm_ne_top _)).mpr (snorm_condexpL2_le hm f)
exact Lp.snorm_ne_top _
| [
" snorm (↑↑↑((condexpL2 E 𝕜 hm) f)) 2 μ ≤ snorm (↑↑f) 2 μ",
" ‖(condexpL2 E 𝕜 hm) f‖ ≤ ‖f‖",
" ‖↑((condexpL2 E 𝕜 hm) f)‖ ≤ ‖f‖",
" (snorm (↑↑↑((condexpL2 E 𝕜 hm) f)) 2 μ).toReal ≤ (snorm (↑↑f) 2 μ).toReal",
" snorm (↑↑↑((condexpL2 E 𝕜 hm) f)) 2 μ ≠ ⊤"
] | [
" snorm (↑↑↑((condexpL2 E 𝕜 hm) f)) 2 μ ≤ snorm (↑↑f) 2 μ",
" ‖(condexpL2 E 𝕜 hm) f‖ ≤ ‖f‖"
] |
import Mathlib.GroupTheory.Solvable
import Mathlib.FieldTheory.PolynomialGaloisGroup
import Mathlib.RingTheory.RootsOfUnity.Basic
#align_import field_theory.abel_ruffini from "leanprover-community/mathlib"@"e3f4be1fcb5376c4948d7f095bec45350bfb9d1a"
noncomputable section
open scoped Classical Polynomial Intermedi... | Mathlib/FieldTheory/AbelRuffini.lean | 39 | 39 | theorem gal_zero_isSolvable : IsSolvable (0 : F[X]).Gal := by | infer_instance
| [
" IsSolvable (Gal 0)"
] | [] |
import Mathlib.RingTheory.Nilpotent.Basic
import Mathlib.RingTheory.UniqueFactorizationDomain
#align_import algebra.squarefree from "leanprover-community/mathlib"@"00d163e35035c3577c1c79fa53b68de17781ffc1"
variable {R : Type*}
def Squarefree [Monoid R] (r : R) : Prop :=
∀ x : R, x * x ∣ r → IsUnit x
#align sq... | Mathlib/Algebra/Squarefree/Basic.lean | 67 | 72 | theorem Irreducible.squarefree [CommMonoid R] {x : R} (h : Irreducible x) : Squarefree x := by |
rintro y ⟨z, hz⟩
rw [mul_assoc] at hz
rcases h.isUnit_or_isUnit hz with (hu | hu)
· exact hu
· apply isUnit_of_mul_isUnit_left hu
| [
" ¬Squarefree 0",
" ∃ x, ¬(x * x ∣ 0 → IsUnit x)",
" ¬(0 * 0 ∣ 0 → IsUnit 0)",
" m ≠ 0",
" False",
" Squarefree x",
" IsUnit y"
] | [
" ¬Squarefree 0",
" ∃ x, ¬(x * x ∣ 0 → IsUnit x)",
" ¬(0 * 0 ∣ 0 → IsUnit 0)",
" m ≠ 0",
" False"
] |
import Mathlib.Algebra.BigOperators.Fin
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sort
import Mathlib.Data.Set.Subsingleton
#align_import combinatorics.composition from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open List
variable {n : ℕ}
... | Mathlib/Combinatorics/Enumerative/Composition.lean | 234 | 236 | theorem sizeUpTo_strict_mono {i : ℕ} (h : i < c.length) : c.sizeUpTo i < c.sizeUpTo (i + 1) := by |
rw [c.sizeUpTo_succ h]
simp
| [
" ∑ i : Fin c.length, c.blocksFun i = n",
"n : ℕ c : Composition n | n",
" c.length ≤ n",
" c.length ≤ c.blocks.sum",
" 0 < c.length",
" 0 < c.blocks.sum",
" c.blocks.sum = n",
" c.sizeUpTo 0 = 0",
" c.sizeUpTo i = n",
" (take i c.blocks).sum = n",
" take i c.blocks = c.blocks",
" c.sizeUpTo i... | [
" ∑ i : Fin c.length, c.blocksFun i = n",
"n : ℕ c : Composition n | n",
" c.length ≤ n",
" c.length ≤ c.blocks.sum",
" 0 < c.length",
" 0 < c.blocks.sum",
" c.blocks.sum = n",
" c.sizeUpTo 0 = 0",
" c.sizeUpTo i = n",
" (take i c.blocks).sum = n",
" take i c.blocks = c.blocks",
" c.sizeUpTo i... |
import Mathlib.Algebra.GCDMonoid.Multiset
import Mathlib.Combinatorics.Enumerative.Partition
import Mathlib.Data.List.Rotate
import Mathlib.GroupTheory.Perm.Cycle.Factors
import Mathlib.GroupTheory.Perm.Closure
import Mathlib.Algebra.GCDMonoid.Nat
import Mathlib.Tactic.NormNum.GCD
#align_import group_theory.perm.cycl... | Mathlib/GroupTheory/Perm/Cycle/Type.lean | 57 | 64 | theorem cycleType_eq' {σ : Perm α} (s : Finset (Perm α)) (h1 : ∀ f : Perm α, f ∈ s → f.IsCycle)
(h2 : (s : Set (Perm α)).Pairwise Disjoint)
(h0 : s.noncommProd id (h2.imp fun _ _ => Disjoint.commute) = σ) :
σ.cycleType = s.1.map (Finset.card ∘ support) := by |
rw [cycleType_def]
congr
rw [cycleFactorsFinset_eq_finset]
exact ⟨h1, h2, h0⟩
| [
" σ.cycleType = Multiset.map (Finset.card ∘ support) s.val",
" Multiset.map (Finset.card ∘ support) σ.cycleFactorsFinset.val = Multiset.map (Finset.card ∘ support) s.val",
" σ.cycleFactorsFinset = s",
" (∀ f ∈ s, f.IsCycle) ∧ ∃ (h : (↑s).Pairwise Disjoint), s.noncommProd id ⋯ = σ"
] | [] |
import Mathlib.NumberTheory.FLT.Basic
import Mathlib.NumberTheory.PythagoreanTriples
import Mathlib.RingTheory.Coprime.Lemmas
import Mathlib.Tactic.LinearCombination
#align_import number_theory.fermat4 from "leanprover-community/mathlib"@"10b4e499f43088dd3bb7b5796184ad5216648ab1"
noncomputable section
open scope... | Mathlib/NumberTheory/FLT/Four.lean | 58 | 62 | theorem ne_zero {a b c : ℤ} (h : Fermat42 a b c) : c ≠ 0 := by |
apply ne_zero_pow two_ne_zero _; apply ne_of_gt
rw [← h.2.2, (by ring : a ^ 4 + b ^ 4 = (a ^ 2) ^ 2 + (b ^ 2) ^ 2)]
exact
add_pos (sq_pos_of_ne_zero (pow_ne_zero 2 h.1)) (sq_pos_of_ne_zero (pow_ne_zero 2 h.2.1))
| [
" Fermat42 a b c ↔ Fermat42 b a c",
" a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2",
" a ≠ 0 ∧ b ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2",
" Fermat42 a b c ↔ Fermat42 (k * a) (k * b) (k ^ 2 * c)",
" a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ k * a ≠ ... | [
" Fermat42 a b c ↔ Fermat42 b a c",
" a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2",
" a ≠ 0 ∧ b ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2 ↔ b ≠ 0 ∧ a ≠ 0 ∧ b ^ 4 + a ^ 4 = c ^ 2",
" Fermat42 a b c ↔ Fermat42 (k * a) (k * b) (k ^ 2 * c)",
" a ≠ 0 ∧ b ≠ 0 ∧ a ^ 4 + b ^ 4 = c ^ 2 ↔ k * a ≠ ... |
import Mathlib.Data.Set.Image
#align_import data.nat.set from "leanprover-community/mathlib"@"cf9386b56953fb40904843af98b7a80757bbe7f9"
namespace Nat
section Set
open Set
| Mathlib/Data/Nat/Set.lean | 21 | 23 | theorem zero_union_range_succ : {0} ∪ range succ = univ := by |
ext n
cases n <;> simp
| [
" {0} ∪ range succ = univ",
" n ∈ {0} ∪ range succ ↔ n ∈ univ",
" 0 ∈ {0} ∪ range succ ↔ 0 ∈ univ",
" n✝ + 1 ∈ {0} ∪ range succ ↔ n✝ + 1 ∈ univ"
] | [] |
import Mathlib.Data.Int.Interval
import Mathlib.RingTheory.Binomial
import Mathlib.RingTheory.HahnSeries.PowerSeries
import Mathlib.RingTheory.HahnSeries.Summable
import Mathlib.FieldTheory.RatFunc.AsPolynomial
import Mathlib.RingTheory.Localization.FractionRing
#align_import ring_theory.laurent_series from "leanprov... | Mathlib/RingTheory/LaurentSeries.lean | 125 | 140 | theorem single_order_mul_powerSeriesPart (x : LaurentSeries R) :
(single x.order 1 : LaurentSeries R) * x.powerSeriesPart = x := by |
ext n
rw [← sub_add_cancel n x.order, single_mul_coeff_add, sub_add_cancel, one_mul]
by_cases h : x.order ≤ n
· rw [Int.eq_natAbs_of_zero_le (sub_nonneg_of_le h), coeff_coe_powerSeries,
powerSeriesPart_coeff, ← Int.eq_natAbs_of_zero_le (sub_nonneg_of_le h),
add_sub_cancel]
· rw [ofPowerSeries_app... | [
" ((ofPowerSeries ℤ R) x).coeff ↑n = (PowerSeries.coeff R n) x",
" powerSeriesPart 0 = 0",
" (PowerSeries.coeff R n✝) (powerSeriesPart 0) = (PowerSeries.coeff R n✝) 0",
" x.powerSeriesPart = 0 ↔ x = 0",
" x.powerSeriesPart = 0 → x = 0",
" x ≠ 0 → x.powerSeriesPart ≠ 0",
" ¬x = 0 → ¬x.powerSeriesPart = 0... | [
" ((ofPowerSeries ℤ R) x).coeff ↑n = (PowerSeries.coeff R n) x",
" powerSeriesPart 0 = 0",
" (PowerSeries.coeff R n✝) (powerSeriesPart 0) = (PowerSeries.coeff R n✝) 0",
" x.powerSeriesPart = 0 ↔ x = 0",
" x.powerSeriesPart = 0 → x = 0",
" x ≠ 0 → x.powerSeriesPart ≠ 0",
" ¬x = 0 → ¬x.powerSeriesPart = 0... |
import Mathlib.MeasureTheory.Measure.MeasureSpace
open scoped ENNReal NNReal Topology
open Set MeasureTheory Measure Filter MeasurableSpace ENNReal Function
variable {R α β δ γ ι : Type*}
namespace MeasureTheory
variable {m0 : MeasurableSpace α} [MeasurableSpace β] [MeasurableSpace γ]
variable {μ μ₁ μ₂ μ₃ ν ν' ν... | Mathlib/MeasureTheory/Measure/Restrict.lean | 110 | 113 | theorem restrict_apply₀' (hs : NullMeasurableSet s μ) : μ.restrict s t = μ (t ∩ s) := by |
rw [← restrict_congr_set hs.toMeasurable_ae_eq,
restrict_apply' (measurableSet_toMeasurable _ _),
measure_congr ((ae_eq_refl t).inter hs.toMeasurable_ae_eq)]
| [
" ((OuterMeasure.restrict s) μ.toOuterMeasure) t =\n ((OuterMeasure.restrict s) μ.toOuterMeasure) (t ∩ s') + ((OuterMeasure.restrict s) μ.toOuterMeasure) (t \\ s')",
" μ (s ∩ t) = μ (s ∩ t ∩ s') + μ ((s ∩ t) \\ s')",
" (μ.restrict s).toOuterMeasure = (OuterMeasure.restrict s) μ.toOuterMeasure",
" (μ.restri... | [
" ((OuterMeasure.restrict s) μ.toOuterMeasure) t =\n ((OuterMeasure.restrict s) μ.toOuterMeasure) (t ∩ s') + ((OuterMeasure.restrict s) μ.toOuterMeasure) (t \\ s')",
" μ (s ∩ t) = μ (s ∩ t ∩ s') + μ ((s ∩ t) \\ s')",
" (μ.restrict s).toOuterMeasure = (OuterMeasure.restrict s) μ.toOuterMeasure",
" (μ.restri... |
import Mathlib.SetTheory.Game.Ordinal
import Mathlib.SetTheory.Ordinal.NaturalOps
#align_import set_theory.game.birthday from "leanprover-community/mathlib"@"a347076985674932c0e91da09b9961ed0a79508c"
universe u
open Ordinal
namespace SetTheory
open scoped NaturalOps PGame
namespace PGame
noncomputable def b... | Mathlib/SetTheory/Game/Birthday.lean | 59 | 61 | theorem birthday_moveRight_lt {x : PGame} (i : x.RightMoves) :
(x.moveRight i).birthday < x.birthday := by |
cases x; rw [birthday]; exact lt_max_of_lt_right (lt_lsub _ i)
| [
" x.birthday = max (lsub fun i => (x.moveLeft i).birthday) (lsub fun i => (x.moveRight i).birthday)",
" (mk α✝ β✝ a✝¹ a✝).birthday =\n max (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday) (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday)",
" max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (... | [
" x.birthday = max (lsub fun i => (x.moveLeft i).birthday) (lsub fun i => (x.moveRight i).birthday)",
" (mk α✝ β✝ a✝¹ a✝).birthday =\n max (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveLeft i).birthday) (lsub fun i => ((mk α✝ β✝ a✝¹ a✝).moveRight i).birthday)",
" max (lsub fun i => (a✝¹ i).birthday) (lsub fun i => (... |
import Mathlib.Algebra.Bounds
import Mathlib.Algebra.Order.Field.Basic -- Porting note: `LinearOrderedField`, etc
import Mathlib.Data.Set.Pointwise.SMul
#align_import algebra.order.pointwise from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Function Set
open Pointwise
variable ... | Mathlib/Algebra/Order/Pointwise.lean | 252 | 262 | theorem smul_Iio : r • Iio a = Iio (r • a) := by |
ext x
simp only [mem_smul_set, smul_eq_mul, mem_Iio]
constructor
· rintro ⟨a_w, a_h_left, rfl⟩
exact (mul_lt_mul_left hr).mpr a_h_left
· rintro h
use x / r
constructor
· exact (div_lt_iff' hr).mpr h
· exact mul_div_cancel₀ _ (ne_of_gt hr)
| [
" r • Ioo a b = Ioo (r • a) (r • b)",
" x ∈ r • Ioo a b ↔ x ∈ Ioo (r • a) (r • b)",
" (∃ y, (a < y ∧ y < b) ∧ r * y = x) ↔ r * a < x ∧ x < r * b",
" (∃ y, (a < y ∧ y < b) ∧ r * y = x) → r * a < x ∧ x < r * b",
" r * a✝ < r * a ∧ r * a < r * b",
" r * a✝ < r * a",
" r * a < r * b",
" r * a < x ∧ x < r ... | [
" r • Ioo a b = Ioo (r • a) (r • b)",
" x ∈ r • Ioo a b ↔ x ∈ Ioo (r • a) (r • b)",
" (∃ y, (a < y ∧ y < b) ∧ r * y = x) ↔ r * a < x ∧ x < r * b",
" (∃ y, (a < y ∧ y < b) ∧ r * y = x) → r * a < x ∧ x < r * b",
" r * a✝ < r * a ∧ r * a < r * b",
" r * a✝ < r * a",
" r * a < r * b",
" r * a < x ∧ x < r ... |
import Mathlib.CategoryTheory.EpiMono
import Mathlib.CategoryTheory.Limits.HasLimits
#align_import category_theory.limits.shapes.equalizers from "leanprover-community/mathlib"@"4698e35ca56a0d4fa53aa5639c3364e0a77f4eba"
section
open CategoryTheory Opposite
namespace CategoryTheory.Limits
-- attribute [local tid... | Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean | 101 | 103 | theorem WalkingParallelPairHom.comp_id
{X Y : WalkingParallelPair} (f : WalkingParallelPairHom X Y) : comp f (id Y) = f := by |
cases f <;> rfl
| [
" f.comp (id Y) = f",
" left.comp (id one) = left",
" right.comp (id one) = right",
" (id X).comp (id X) = id X"
] | [] |
import Mathlib.Algebra.TrivSqZeroExt
import Mathlib.Topology.Algebra.InfiniteSum.Basic
import Mathlib.Topology.Algebra.Module.Basic
#align_import topology.instances.triv_sq_zero_ext from "leanprover-community/mathlib"@"b8d2eaa69d69ce8f03179a5cda774fc0cde984e4"
open scoped Topology
variable {α S R M : Type*}
local... | Mathlib/Topology/Instances/TrivSqZeroExt.lean | 46 | 48 | theorem nhds_def (x : tsze R M) : 𝓝 x = (𝓝 x.fst).prod (𝓝 x.snd) := by |
cases x using Prod.rec
exact nhds_prod_eq
| [
" 𝓝 x = (𝓝 x.fst).prod (𝓝 x.snd)",
" 𝓝 (fst✝, snd✝) = (𝓝 (fst (fst✝, snd✝))).prod (𝓝 (snd (fst✝, snd✝)))"
] | [] |
import Mathlib.LinearAlgebra.Basis.VectorSpace
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.SetTheory.Cardinal.Subfield
import Mathlib.LinearAlgebra.Dimension.RankNullity
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomput... | Mathlib/LinearAlgebra/Dimension/DivisionRing.lean | 123 | 166 | theorem linearIndependent_of_top_le_span_of_card_eq_finrank {ι : Type*} [Fintype ι] {b : ι → V}
(spans : ⊤ ≤ span K (Set.range b)) (card_eq : Fintype.card ι = finrank K V) :
LinearIndependent K b :=
linearIndependent_iff'.mpr fun s g dependent i i_mem_s => by
classical
by_contra gx_ne_zero
-- We'l... |
rw [Set.toFinset_card, Fintype.card_ofFinset]
_ ≤ (Set.univ \ {i}).toFinset.card := Finset.card_image_le
_ = (Finset.univ.erase i).card := (congr_arg Finset.card (Finset.ext (by simp [and_comm])))
_ < Finset.univ.card := Finset.card_erase_lt_of_mem (Finset.mem_univ i)
_ = finr... | [
" g i = 0",
" False",
" (b '' (Set.univ \\ {i})).toFinset.card < finrank K V",
" (b '' (Set.univ \\ {i})).toFinset.card = (Finset.image b (Set.univ \\ {i}).toFinset).card",
" ∀ (a : ι), a ∈ (Set.univ \\ {i}).toFinset ↔ a ∈ Finset.univ.erase i",
" ⊤ ≤ span K (b '' (Set.univ \\ {i}))",
" range b ⊆ ↑(span ... | [] |
import Mathlib.NumberTheory.LegendreSymbol.Basic
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.GaussSum
#align_import number_theory.legendre_symbol.quadratic_reciprocity from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Nat
section Values
variable {p : ℕ} [Fact p.Pri... | Mathlib/NumberTheory/LegendreSymbol/QuadraticReciprocity.lean | 60 | 62 | theorem at_two : legendreSym p 2 = χ₈ p := by |
have : (2 : ZMod p) = (2 : ℤ) := by norm_cast
rw [legendreSym, ← this, quadraticChar_two ((ringChar_zmod_n p).substr hp), card p]
| [
" legendreSym p 2 = χ₈ ↑p",
" 2 = ↑2"
] | [] |
import Mathlib.Order.Cover
import Mathlib.Order.Interval.Finset.Defs
#align_import data.finset.locally_finite from "leanprover-community/mathlib"@"442a83d738cb208d3600056c489be16900ba701d"
assert_not_exists MonoidWithZero
assert_not_exists Finset.sum
open Function OrderDual
open FinsetInterval
variable {ι α : T... | Mathlib/Order/Interval/Finset/Basic.lean | 57 | 58 | theorem nonempty_Icc : (Icc a b).Nonempty ↔ a ≤ b := by |
rw [← coe_nonempty, coe_Icc, Set.nonempty_Icc]
| [
" (Icc a b).Nonempty ↔ a ≤ b"
] | [] |
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 | 629 | 630 | theorem preimage_mul_const_Ico (a b : α) {c : α} (h : 0 < c) :
(fun x => x * c) ⁻¹' Ico a b = Ico (a / c) (b / c) := by | simp [← Ici_inter_Iio, h]
| [
" (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) ⁻¹' Ioo a b = Ioo (a / c) (b / c)",
" (fun x => x * c) ⁻¹' Ioc a b = Ioc (a / c) (b / c)"
] |
import Mathlib.Analysis.Complex.AbsMax
import Mathlib.Analysis.Asymptotics.SuperpolynomialDecay
#align_import analysis.complex.phragmen_lindelof from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Function Filter Asymptotics Metric Complex Bornology
open scoped Topology Filter R... | Mathlib/Analysis/Complex/PhragmenLindelof.lean | 80 | 94 | theorem isBigO_sub_exp_rpow {a : ℝ} {f g : ℂ → E} {l : Filter ℂ}
(hBf : ∃ c < a, ∃ B, f =O[cobounded ℂ ⊓ l] fun z => expR (B * abs z ^ c))
(hBg : ∃ c < a, ∃ B, g =O[cobounded ℂ ⊓ l] fun z => expR (B * abs z ^ c)) :
∃ c < a, ∃ B, (f - g) =O[cobounded ℂ ⊓ l] fun z => expR (B * abs z ^ c) := by |
have : ∀ {c₁ c₂ B₁ B₂ : ℝ}, c₁ ≤ c₂ → 0 ≤ B₂ → B₁ ≤ B₂ →
(fun z : ℂ => expR (B₁ * abs z ^ c₁)) =O[cobounded ℂ ⊓ l]
fun z => expR (B₂ * abs z ^ c₂) := fun hc hB₀ hB ↦ .of_bound 1 <| by
filter_upwards [(eventually_cobounded_le_norm 1).filter_mono inf_le_left] with z hz
simp only [one_mul, Real.no... | [
" ∃ c < a, ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * |u z|))",
" ‖expR (B₁✝ * expR (c₁✝ * |u z|))‖ ≤ ‖expR (B₂✝ * expR (c₂✝ * |u z|))‖",
" expR (B₁✝ * expR (c₁✝ * |u z|)) ≤ expR (B₂✝ * expR (c₂✝ * |u z|))",
" (f - g) =O[l] fun z => expR (max 0 (max Bf Bg) * expR (max cf cg * |u z|))",
" Bg ≤ max 0 (ma... | [
" ∃ c < a, ∃ B, (f - g) =O[l] fun z => expR (B * expR (c * |u z|))",
" ‖expR (B₁✝ * expR (c₁✝ * |u z|))‖ ≤ ‖expR (B₂✝ * expR (c₂✝ * |u z|))‖",
" expR (B₁✝ * expR (c₁✝ * |u z|)) ≤ expR (B₂✝ * expR (c₂✝ * |u z|))",
" (f - g) =O[l] fun z => expR (max 0 (max Bf Bg) * expR (max cf cg * |u z|))",
" Bg ≤ max 0 (ma... |
import Mathlib.Data.Finset.Lattice
import Mathlib.Data.Fintype.Vector
import Mathlib.Data.Multiset.Sym
#align_import data.finset.sym from "leanprover-community/mathlib"@"02ba8949f486ebecf93fe7460f1ed0564b5e442c"
namespace Finset
variable {α : Type*}
@[simps]
protected def sym2 (s : Finset α) : Finset (Sym2 α) :... | Mathlib/Data/Finset/Sym.lean | 114 | 115 | theorem card_sym2 (s : Finset α) : s.sym2.card = Nat.choose (s.card + 1) 2 := by |
rw [card_def, sym2_val, Multiset.card_sym2, ← card_def]
| [
" s(a, b) ∈ s.sym2 ↔ a ∈ s ∧ b ∈ s",
" m ∈ s.sym2 ↔ ∀ a ∈ m, a ∈ s",
" (∀ y ∈ m, y ∈ s.val) ↔ ∀ a ∈ m, a ∈ s",
" x ∈ univ.sym2",
" ∀ a ∈ x, a ∈ univ",
" univ.sym2 = univ",
" a✝ ∈ univ.sym2 ↔ a✝ ∈ univ",
" s.sym2 ⊆ t.sym2",
" s.val.sym2 ≤ t.val.sym2",
" s.val ≤ t.val",
" Function.Injective Finset... | [
" s(a, b) ∈ s.sym2 ↔ a ∈ s ∧ b ∈ s",
" m ∈ s.sym2 ↔ ∀ a ∈ m, a ∈ s",
" (∀ y ∈ m, y ∈ s.val) ↔ ∀ a ∈ m, a ∈ s",
" x ∈ univ.sym2",
" ∀ a ∈ x, a ∈ univ",
" univ.sym2 = univ",
" a✝ ∈ univ.sym2 ↔ a✝ ∈ univ",
" s.sym2 ⊆ t.sym2",
" s.val.sym2 ≤ t.val.sym2",
" s.val ≤ t.val",
" Function.Injective Finset... |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.TensorProduct.Tower
import Mathlib.RingTheory.Adjoin.Basic
import Mathlib.LinearAlgebra.DirectSum.Finsupp
#align_import ring_theory.tensor_product from "leanprover-community/mathlib"@"88fcdc3da43943f5b01925deddaa5bf0c0e85e4e"
suppress_comp... | Mathlib/RingTheory/TensorProduct/Basic.lean | 96 | 98 | theorem baseChange_smul : (r • f).baseChange A = r • f.baseChange A := by |
ext
simp [baseChange_tmul]
| [
" baseChange A (f + g) = baseChange A f + baseChange A g",
" ((AlgebraTensorModule.curry (baseChange A (f + g))) 1) x✝ =\n ((AlgebraTensorModule.curry (baseChange A f + baseChange A g)) 1) x✝",
" baseChange A 0 = 0",
" ((AlgebraTensorModule.curry (baseChange A 0)) 1) x✝ = ((AlgebraTensorModule.curry 0) 1) ... | [
" baseChange A (f + g) = baseChange A f + baseChange A g",
" ((AlgebraTensorModule.curry (baseChange A (f + g))) 1) x✝ =\n ((AlgebraTensorModule.curry (baseChange A f + baseChange A g)) 1) x✝",
" baseChange A 0 = 0",
" ((AlgebraTensorModule.curry (baseChange A 0)) 1) x✝ = ((AlgebraTensorModule.curry 0) 1) ... |
import Mathlib.MeasureTheory.Constructions.BorelSpace.Order
#align_import measure_theory.function.simple_func from "leanprover-community/mathlib"@"bf6a01357ff5684b1ebcd0f1a13be314fc82c0bf"
noncomputable section
open Set hiding restrict restrict_apply
open Filter ENNReal
open Function (support)
open scoped Cla... | Mathlib/MeasureTheory/Function/SimpleFunc.lean | 125 | 126 | theorem forall_mem_range {f : α →ₛ β} {p : β → Prop} : (∀ y ∈ f.range, p y) ↔ ∀ x, p (f x) := by |
simp only [mem_range, Set.forall_mem_range]
| [
" f = g",
" { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = g",
" { toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' :=... | [
" f = g",
" { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' := finite_range'✝ } = g",
" { toFun := toFun✝¹, measurableSet_fiber' := measurableSet_fiber'✝¹, finite_range' := finite_range'✝¹ } =\n { toFun := toFun✝, measurableSet_fiber' := measurableSet_fiber'✝, finite_range' :=... |
import Mathlib.Combinatorics.Quiver.Basic
import Mathlib.Combinatorics.Quiver.Path
#align_import combinatorics.quiver.cast from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
universe v v₁ v₂ u u₁ u₂
variable {U : Type*} [Quiver.{u + 1} U]
namespace Quiver
def Hom.cast {u v u' v... | Mathlib/Combinatorics/Quiver/Cast.lean | 38 | 41 | theorem Hom.cast_eq_cast {u v u' v' : U} (hu : u = u') (hv : v = v') (e : u ⟶ v) :
e.cast hu hv = _root_.cast (by {rw [hu, hv]}) e := by |
subst_vars
rfl
| [
" (u ⟶ v) = (u' ⟶ v')",
" cast hu hv e = _root_.cast ⋯ e",
" cast ⋯ ⋯ e = _root_.cast ⋯ e"
] | [] |
import Mathlib.Algebra.MvPolynomial.Variables
#align_import data.mv_polynomial.comm_ring from "leanprover-community/mathlib"@"2f5b500a507264de86d666a5f87ddb976e2d8de4"
noncomputable section
open Set Function Finsupp AddMonoidAlgebra
universe u v
variable {R : Type u} {S : Type v}
namespace MvPolynomial
varia... | Mathlib/Algebra/MvPolynomial/CommRing.lean | 207 | 212 | theorem totalDegree_sub (a b : MvPolynomial σ R) :
(a - b).totalDegree ≤ max a.totalDegree b.totalDegree :=
calc
(a - b).totalDegree = (a + -b).totalDegree := by | rw [sub_eq_add_neg]
_ ≤ max a.totalDegree (-b).totalDegree := totalDegree_add a (-b)
_ = max a.totalDegree b.totalDegree := by rw [totalDegree_neg]
| [
" (-a).totalDegree = a.totalDegree",
" (a - b).totalDegree = (a + -b).totalDegree",
" max a.totalDegree (-b).totalDegree = max a.totalDegree b.totalDegree"
] | [
" (-a).totalDegree = a.totalDegree"
] |
import Mathlib.Init.Function
import Mathlib.Logic.Function.Basic
import Mathlib.Tactic.Inhabit
#align_import data.prod.basic from "leanprover-community/mathlib"@"d07245fd37786daa997af4f1a73a49fa3b748408"
variable {α : Type*} {β : Type*} {γ : Type*} {δ : Type*}
@[simp]
theorem Prod.map_apply (f : α → γ) (g : β → δ... | Mathlib/Data/Prod/Basic.lean | 110 | 113 | theorem mk.inj_right {α β : Type*} (b : β) :
Function.Injective (fun a ↦ Prod.mk a b : α → α × β) := by |
intro b₁ b₂ h
simpa only [and_true, eq_self_iff_true, mk.inj_iff] using h
| [
" Function.Injective (mk a)",
" b₁ = b₂",
" Function.Injective fun a => (a, b)"
] | [
" Function.Injective (mk a)",
" b₁ = b₂"
] |
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import analysis.special_functions.complex.log from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
namespace Complex
open Set Filter Bornology
open scop... | Mathlib/Analysis/SpecialFunctions/Complex/Log.lean | 110 | 110 | theorem log_one : log 1 = 0 := by | simp [log]
| [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -π < x.log.im",
" x.log.im ≤ π",
" cexp x.log = x",
" x ∈ Set.range cexp → x ∈ {0}ᶜ",
" cexp x ∈ {0}ᶜ",
" (cexp x).log = x",
" x = y",
" (↑x.log).re = (↑x).log.re",
" (↑x.log).im = (↑x).log.im",
" (↑x).log.re = x.log",
" (↑r * x).log = ↑r.log... | [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -π < x.log.im",
" x.log.im ≤ π",
" cexp x.log = x",
" x ∈ Set.range cexp → x ∈ {0}ᶜ",
" cexp x ∈ {0}ᶜ",
" (cexp x).log = x",
" x = y",
" (↑x.log).re = (↑x).log.re",
" (↑x.log).im = (↑x).log.im",
" (↑x).log.re = x.log",
" (↑r * x).log = ↑r.log... |
import Mathlib.Algebra.Field.Basic
import Mathlib.Algebra.GroupWithZero.Units.Equiv
import Mathlib.Algebra.Order.Field.Defs
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Order.Bounds.OrderIso
import Mathlib.Tactic.Positivity.Core
#align_import algebra.order.field.basic from "leanprover-community/mathlib"@"8477... | Mathlib/Algebra/Order/Field/Basic.lean | 76 | 76 | theorem div_le_iff' (hb : 0 < b) : a / b ≤ c ↔ a ≤ b * c := by | rw [mul_comm, div_le_iff hb]
| [
" a ≤ b / c ↔ c * a ≤ b",
" a = a / b * b",
" c * b / b = c",
" a / b ≤ c ↔ a ≤ b * c"
] | [
" a ≤ b / c ↔ c * a ≤ b",
" a = a / b * b",
" c * b / b = c"
] |
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 | 142 | 143 | theorem log_le_log_iff (h : 0 < x) (h₁ : 0 < y) : log x ≤ log y ↔ x ≤ y := by |
rw [← exp_le_exp, exp_log h, exp_log h₁]
| [
" 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 ≤ rexp x.log",
" 0 ≤ 1",
" x ≤ |x|",
" rexp (log 1) = rexp 0",
" |x|.log = x.log",
" (-x).log = x.log",
" 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",
" |x| = -x",
" x ≤ rexp x.log",
" 0 ≤ 1",
" x ≤ |x|",
" rexp (log 1) = rexp 0",
" |x|.log = x.log",
" (-x).log = x.log",
" x... |
import Mathlib.NumberTheory.Cyclotomic.Discriminant
import Mathlib.RingTheory.Polynomial.Eisenstein.IsIntegral
import Mathlib.RingTheory.Ideal.Norm
#align_import number_theory.cyclotomic.rat from "leanprover-community/mathlib"@"b353176c24d96c23f0ce1cc63efc3f55019702d9"
universe u
open Algebra IsCyclotomicExtensio... | Mathlib/NumberTheory/Cyclotomic/Rat.lean | 46 | 49 | theorem discr_odd_prime' [IsCyclotomicExtension {p} ℚ K] (hζ : IsPrimitiveRoot ζ p) (hodd : p ≠ 2) :
discr ℚ (hζ.subOnePowerBasis ℚ).basis = (-1) ^ (((p : ℕ) - 1) / 2) * p ^ ((p : ℕ) - 2) := by |
rw [← discr_odd_prime hζ (cyclotomic.irreducible_rat hp.out.pos) hodd]
exact hζ.discr_zeta_eq_discr_zeta_sub_one.symm
| [
" Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =\n (-1) ^ (φ (↑p ^ (k + 1)) / 2) * ↑↑p ^ (↑p ^ k * ((↑p - 1) * (k + 1) - 1))",
" Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =\n Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis",
" Algebra.discr ℚ ⇑(IsPrimitiveRo... | [
" Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =\n (-1) ^ (φ (↑p ^ (k + 1)) / 2) * ↑↑p ^ (↑p ^ k * ((↑p - 1) * (k + 1) - 1))",
" Algebra.discr ℚ ⇑(IsPrimitiveRoot.subOnePowerBasis ℚ hζ).basis =\n Algebra.discr ℚ ⇑(IsPrimitiveRoot.powerBasis ℚ hζ).basis"
] |
import Mathlib.Topology.Order
#align_import topology.maps from "leanprover-community/mathlib"@"d91e7f7a7f1c7e9f0e18fdb6bde4f652004c735d"
open Set Filter Function
open TopologicalSpace Topology Filter
variable {X : Type*} {Y : Type*} {Z : Type*} {ι : Type*} {f : X → Y} {g : Y → Z}
section Inducing
variable [To... | Mathlib/Topology/Maps.lean | 137 | 139 | theorem continuousAt_iff' (hf : Inducing f) {x : X} (h : range f ∈ 𝓝 (f x)) :
ContinuousAt (g ∘ f) x ↔ ContinuousAt g (f x) := by |
simp_rw [ContinuousAt, Filter.Tendsto, ← hf.map_nhds_of_mem _ h, Filter.map_map, comp]
| [
" inst✝² = TopologicalSpace.induced (g ∘ f) inst✝",
" Inducing (g ∘ f) ↔ Inducing f",
" Inducing f",
" inst✝² ≤ induced f inst✝¹",
" induced f inst✝¹ ≤ inst✝²",
" induced f inst✝¹ ≤ induced f (induced g inst✝)",
" 𝓝ˢ s = comap f (𝓝ˢ (f '' s))",
" MapClusterPt (f x) l f ↔ ClusterPt x l",
" (𝓝 (f x... | [
" inst✝² = TopologicalSpace.induced (g ∘ f) inst✝",
" Inducing (g ∘ f) ↔ Inducing f",
" Inducing f",
" inst✝² ≤ induced f inst✝¹",
" induced f inst✝¹ ≤ inst✝²",
" induced f inst✝¹ ≤ induced f (induced g inst✝)",
" 𝓝ˢ s = comap f (𝓝ˢ (f '' s))",
" MapClusterPt (f x) l f ↔ ClusterPt x l",
" (𝓝 (f x... |
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 | 138 | 139 | theorem le_inv_mul_iff_le : 1 ≤ b⁻¹ * a ↔ b ≤ a := by |
rw [← mul_le_mul_iff_left b, mul_one, mul_inv_cancel_left]
| [
" b ≤ c",
" a⁻¹ ≤ 1 ↔ 1 ≤ a",
" a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a",
" 1 ≤ a⁻¹ ↔ a ≤ 1",
" a * 1 ≤ a * a⁻¹ ↔ a ≤ 1",
" 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",
" a⁻¹ ≤ 1 ↔ 1 ≤ a",
" a * a⁻¹ ≤ a * 1 ↔ 1 ≤ a",
" 1 ≤ a⁻¹ ↔ a ≤ 1",
" a * 1 ≤ a * a⁻¹ ↔ a ≤ 1",
" 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"
] |
import Mathlib.Algebra.Algebra.Tower
import Mathlib.Algebra.Polynomial.AlgebraMap
#align_import ring_theory.polynomial.tower from "leanprover-community/mathlib"@"bb168510ef455e9280a152e7f31673cabd3d7496"
open Polynomial
variable (R A B : Type*)
namespace Polynomial
section CommSemiring
variable [CommSemiring ... | Mathlib/RingTheory/Polynomial/Tower.lean | 60 | 63 | theorem aeval_algebraMap_eq_zero_iff [NoZeroSMulDivisors A B] [Nontrivial B] (x : A) (p : R[X]) :
aeval (algebraMap A B x) p = 0 ↔ aeval x p = 0 := by |
rw [aeval_algebraMap_apply, Algebra.algebraMap_eq_smul_one, smul_eq_zero,
iff_false_intro (one_ne_zero' B), or_false_iff]
| [
" (aeval ((algebraMap A B) x)) p = (algebraMap A B) ((aeval x) p)",
" (aeval ((algebraMap A B) x)) p = 0 ↔ (aeval x) p = 0"
] | [
" (aeval ((algebraMap A B) x)) p = (algebraMap A B) ((aeval x) p)"
] |
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 | 199 | 199 | theorem bagInter_nil (l : List α) : l.bagInter [] = [] := by | cases l <;> rfl
| [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []",
" l.bagInter [] = []",
" (head✝ :: tail✝).bagInter [] = []"
] | [
" [].bagInter l = []",
" [].bagInter [] = []",
" [].bagInter (head✝ :: tail✝) = []"
] |
import Mathlib.SetTheory.Ordinal.Arithmetic
import Mathlib.Tactic.TFAE
import Mathlib.Topology.Order.Monotone
#align_import set_theory.ordinal.topology from "leanprover-community/mathlib"@"740acc0e6f9adf4423f92a485d0456fc271482da"
noncomputable section
universe u v
open Cardinal Order Topology
namespace Ordina... | Mathlib/SetTheory/Ordinal/Topology.lean | 86 | 124 | theorem mem_closure_tfae (a : Ordinal.{u}) (s : Set Ordinal) :
TFAE [a ∈ closure s,
a ∈ closure (s ∩ Iic a),
(s ∩ Iic a).Nonempty ∧ sSup (s ∩ Iic a) = a,
∃ t, t ⊆ s ∧ t.Nonempty ∧ BddAbove t ∧ sSup t = a,
∃ (o : Ordinal.{u}), o ≠ 0 ∧ ∃ (f : ∀ x < o, Ordinal),
(∀ x hx, f x hx ∈ s) ∧ b... |
tfae_have 1 → 2
· simp only [mem_closure_iff_nhdsWithin_neBot, inter_comm s, nhdsWithin_inter', nhds_left_eq_nhds]
exact id
tfae_have 2 → 3
· intro h
rcases (s ∩ Iic a).eq_empty_or_nonempty with he | hne
· simp [he] at h
· refine ⟨hne, (isLUB_of_mem_closure ?_ h).csSup_eq hne⟩
exact fun x... | [
" IsOpen {a} ↔ ¬a.IsLimit",
" False",
" IsOpen {a}",
" IsOpen {0}",
" IsOpen (Set.Iio (succ ⊥))",
" IsOpen {succ b}",
" IsOpen (Set.Ioo b (succ (succ b)))",
" 𝓝[<] a = 𝓝[≠] a",
" 𝓝[≤] a = 𝓝 a",
" IsOpen s ↔ ∀ o ∈ s, o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s",
" s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set... | [
" IsOpen {a} ↔ ¬a.IsLimit",
" False",
" IsOpen {a}",
" IsOpen {0}",
" IsOpen (Set.Iio (succ ⊥))",
" IsOpen {succ b}",
" IsOpen (Set.Ioo b (succ (succ b)))",
" 𝓝[<] a = 𝓝[≠] a",
" 𝓝[≤] a = 𝓝 a",
" IsOpen s ↔ ∀ o ∈ s, o.IsLimit → ∃ a < o, Set.Ioo a o ⊆ s",
" s ∈ 𝓝 o ↔ o.IsLimit → ∃ a < o, Set... |
import Mathlib.Algebra.IsPrimePow
import Mathlib.NumberTheory.ArithmeticFunction
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import number_theory.von_mangoldt from "leanprover-community/mathlib"@"c946d6097a6925ad16d7ec55677bbc977f9846de"
namespace ArithmeticFunction
open Finset Nat
open scoped Arit... | Mathlib/NumberTheory/VonMangoldt.lean | 90 | 91 | theorem vonMangoldt_apply_pow {n k : ℕ} (hk : k ≠ 0) : Λ (n ^ k) = Λ n := by |
simp only [vonMangoldt_apply, isPrimePow_pow_iff hk, pow_minFac hk]
| [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0",
" Λ (n ^ k) = Λ n"
] | [
" (fun n => (↑n).log) 0 = 0",
" Λ 1 = 0",
" 0 ≤ Λ n",
" 0 ≤ if IsPrimePow n then (↑n.minFac).log else 0",
" 0 ≤ (↑n.minFac).log",
" 0 ≤ 0"
] |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Module.Defs
import Mathlib.Algebra.Order.Archimedean
import Mathlib.Algebra.Order.Group.Instances
import Mathlib.GroupTheory.GroupAction.Pi
open Function Set
structure AddConstMap (G H : Type*) [Add G] [Add H] (a : G) (b : H) where
protected... | Mathlib/Algebra/AddConstMap/Basic.lean | 121 | 122 | theorem map_nat [AddMonoidWithOne G] [AddMonoidWithOne H] [AddConstMapClass F G H 1 1]
(f : F) (n : ℕ) : f n = f 0 + n := by | simp
| [
" f (x + n • a) = f x + n • b",
" f (x + ↑n) = f x + n • b",
" f (x + ↑n) = f x + ↑n",
" f a = f 0 + b",
" f (n • a) = f 0 + n • b",
" f ↑n = f 0 + n • b",
" f ↑n = f 0 + ↑n"
] | [
" f (x + n • a) = f x + n • b",
" f (x + ↑n) = f x + n • b",
" f (x + ↑n) = f x + ↑n",
" f a = f 0 + b",
" f (n • a) = f 0 + n • b",
" f ↑n = f 0 + n • b"
] |
import Mathlib.CategoryTheory.EpiMono
import Mathlib.CategoryTheory.Limits.HasLimits
#align_import category_theory.limits.shapes.equalizers from "leanprover-community/mathlib"@"4698e35ca56a0d4fa53aa5639c3364e0a77f4eba"
section
open CategoryTheory Opposite
namespace CategoryTheory.Limits
-- attribute [local tid... | Mathlib/CategoryTheory/Limits/Shapes/Equalizers.lean | 105 | 108 | theorem WalkingParallelPairHom.assoc {X Y Z W : WalkingParallelPair}
(f : WalkingParallelPairHom X Y) (g: WalkingParallelPairHom Y Z)
(h : WalkingParallelPairHom Z W) : comp (comp f g) h = comp f (comp g h) := by |
cases f <;> cases g <;> cases h <;> rfl
| [
" f.comp (id Y) = f",
" left.comp (id one) = left",
" right.comp (id one) = right",
" (id X).comp (id X) = id X",
" (f.comp g).comp h = f.comp (g.comp h)",
" (left.comp g).comp h = left.comp (g.comp h)",
" (right.comp g).comp h = right.comp (g.comp h)",
" ((id X).comp g).comp h = (id X).comp (g.comp h... | [
" f.comp (id Y) = f",
" left.comp (id one) = left",
" right.comp (id one) = right",
" (id X).comp (id X) = id X"
] |
import Mathlib.Algebra.Field.Basic
import Mathlib.Deprecated.Subring
#align_import deprecated.subfield from "leanprover-community/mathlib"@"bd9851ca476957ea4549eb19b40e7b5ade9428cc"
variable {F : Type*} [Field F] (S : Set F)
structure IsSubfield extends IsSubring S : Prop where
inv_mem : ∀ {x : F}, x ∈ S → x⁻... | Mathlib/Deprecated/Subfield.lean | 40 | 43 | theorem IsSubfield.div_mem {S : Set F} (hS : IsSubfield S) {x y : F} (hx : x ∈ S) (hy : y ∈ S) :
x / y ∈ S := by |
rw [div_eq_mul_inv]
exact hS.toIsSubring.toIsSubmonoid.mul_mem hx (hS.inv_mem hy)
| [
" x / y ∈ S",
" x * y⁻¹ ∈ S"
] | [] |
import Mathlib.CategoryTheory.Limits.Shapes.ZeroMorphisms
import Mathlib.CategoryTheory.Limits.Shapes.Kernels
import Mathlib.CategoryTheory.Abelian.Basic
import Mathlib.CategoryTheory.Subobject.Lattice
import Mathlib.Order.Atoms
#align_import category_theory.simple from "leanprover-community/mathlib"@"4ed0bcaef698011... | Mathlib/CategoryTheory/Simple.lean | 84 | 89 | theorem kernel_zero_of_nonzero_from_simple {X Y : C} [Simple X] {f : X ⟶ Y} [HasKernel f]
(w : f ≠ 0) : kernel.ι f = 0 := by |
classical
by_contra h
haveI := isIso_of_mono_of_nonzero h
exact w (eq_zero_of_epi_kernel f)
| [
" IsIso f ↔ f ≠ 0",
" IsIso f → f ≠ 0",
" False",
" IsIso (f ≫ i.hom)",
" f ≠ 0 → IsIso f",
" IsIso f",
" f ≫ i.hom ≠ 0",
" f = 0",
" IsIso ((f ≫ i.hom) ≫ i.inv)",
" kernel.ι f = 0"
] | [
" IsIso f ↔ f ≠ 0",
" IsIso f → f ≠ 0",
" False",
" IsIso (f ≫ i.hom)",
" f ≠ 0 → IsIso f",
" IsIso f",
" f ≫ i.hom ≠ 0",
" f = 0",
" IsIso ((f ≫ i.hom) ≫ i.inv)"
] |
import Mathlib.Algebra.Algebra.Operations
import Mathlib.Algebra.Algebra.Subalgebra.Basic
import Mathlib.Algebra.Ring.Subring.Pointwise
import Mathlib.RingTheory.Adjoin.Basic
#align_import algebra.algebra.subalgebra.pointwise from "leanprover-community/mathlib"@"b2c707cd190a58ea0565c86695a19e99ccecc215"
namespace... | Mathlib/Algebra/Algebra/Subalgebra/Pointwise.lean | 37 | 44 | theorem mul_self (S : Subalgebra R A) : (Subalgebra.toSubmodule S) * (Subalgebra.toSubmodule S)
= (Subalgebra.toSubmodule S) := by |
apply le_antisymm
· refine (mul_toSubmodule_le _ _).trans_eq ?_
rw [sup_idem]
· intro x hx1
rw [← mul_one x]
exact Submodule.mul_mem_mul hx1 (show (1 : A) ∈ S from one_mem S)
| [
" toSubmodule S * toSubmodule T ≤ toSubmodule (S ⊔ T)",
" ∀ m ∈ toSubmodule S, ∀ n ∈ toSubmodule T, m * n ∈ toSubmodule (S ⊔ T)",
" y * z ∈ toSubmodule (S ⊔ T)",
" y * z ∈ S ⊔ T",
" toSubmodule S * toSubmodule S = toSubmodule S",
" toSubmodule S * toSubmodule S ≤ toSubmodule S",
" toSubmodule (S ⊔ S) = ... | [
" toSubmodule S * toSubmodule T ≤ toSubmodule (S ⊔ T)",
" ∀ m ∈ toSubmodule S, ∀ n ∈ toSubmodule T, m * n ∈ toSubmodule (S ⊔ T)",
" y * z ∈ toSubmodule (S ⊔ T)",
" y * z ∈ S ⊔ T"
] |
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 | 92 | 95 | theorem Iic_mul_Iio_subset' (a b : α) : Iic a * Iio b ⊆ Iio (a * b) := by |
haveI := covariantClass_le_of_lt
rintro x ⟨y, hya, z, hzb, rfl⟩
exact mul_lt_mul_of_le_of_lt hya hzb
| [
" Icc a b * Ico c d ⊆ Ico (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z ∈ Ico (a * c) (b * d)",
" Ico a b * Icc c d ⊆ Ico (a * c) (b * d)",
" Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z ∈ Ioo (a * c) (b * d)",
" Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)",
" Iic a * Iio b ⊆ Iio ... | [
" Icc a b * Ico c d ⊆ Ico (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z ∈ Ico (a * c) (b * d)",
" Ico a b * Icc c d ⊆ Ico (a * c) (b * d)",
" Ioc a b * Ico c d ⊆ Ioo (a * c) (b * d)",
" (fun x x_1 => x * x_1) y z ∈ Ioo (a * c) (b * d)",
" Ico a b * Ioc c d ⊆ Ioo (a * c) (b * d)"
] |
import Mathlib.RingTheory.WittVector.InitTail
#align_import ring_theory.witt_vector.truncated from "leanprover-community/mathlib"@"acbe099ced8be9c9754d62860110295cde0d7181"
open Function (Injective Surjective)
noncomputable section
variable {p : ℕ} [hp : Fact p.Prime] (n : ℕ) (R : Type*)
local notation "𝕎" =>... | Mathlib/RingTheory/WittVector/Truncated.lean | 114 | 115 | theorem coeff_out (x : TruncatedWittVector p n R) (i : Fin n) : x.out.coeff i = x.coeff i := by |
rw [out]; dsimp only; rw [dif_pos i.is_lt, Fin.eta]
| [
" coeff i x = coeff i y",
" (mk p fun i => coeff i x) = x",
" coeff i (mk p fun i => coeff i x) = coeff i x",
" x.out.coeff ↑i = coeff i x",
" { coeff := fun i => if h : i < n then coeff ⟨i, h⟩ x else 0 }.coeff ↑i = coeff i x",
" (if h : ↑i < n then coeff ⟨↑i, h⟩ x else 0) = coeff i x"
] | [
" coeff i x = coeff i y",
" (mk p fun i => coeff i x) = x",
" coeff i (mk p fun i => coeff i x) = coeff i x"
] |
import Mathlib.Data.Set.Lattice
#align_import data.semiquot from "leanprover-community/mathlib"@"09597669f02422ed388036273d8848119699c22f"
-- Porting note: removed universe parameter
structure Semiquot (α : Type*) where mk' ::
s : Set α
val : Trunc s
#align semiquot Semiquot
namespace Semiquot
vari... | Mathlib/Data/Semiquot.lean | 90 | 91 | theorem blur_eq_blur' (q : Semiquot α) (s : Set α) (h : q.s ⊆ s) : blur s q = blur' q h := by |
unfold blur; congr; exact Set.union_eq_self_of_subset_right h
| [
" q₁ = q₂ ↔ q₁.s = q₂.s",
" q₁ = q₂",
" { s := s✝, val := v₁ } = q₂",
" { s := s✝¹, val := v₁ } = { s := s✝, val := v₂ }",
" HEq v₁ v₂",
" blur s q = q.blur' h",
" q.blur' ⋯ = q.blur' h",
" s ∪ q.s = s"
] | [
" q₁ = q₂ ↔ q₁.s = q₂.s",
" q₁ = q₂",
" { s := s✝, val := v₁ } = q₂",
" { s := s✝¹, val := v₁ } = { s := s✝, val := v₂ }",
" HEq v₁ v₂"
] |
import Mathlib.MeasureTheory.Function.LpSeminorm.Basic
import Mathlib.MeasureTheory.Integral.MeanInequalities
#align_import measure_theory.function.lp_seminorm from "leanprover-community/mathlib"@"c4015acc0a223449d44061e27ddac1835a3852b9"
open Filter
open scoped ENNReal Topology
namespace MeasureTheory
section S... | Mathlib/MeasureTheory/Function/LpSeminorm/CompareExp.lean | 61 | 85 | theorem snorm_le_snorm_mul_rpow_measure_univ {p q : ℝ≥0∞} (hpq : p ≤ q)
(hf : AEStronglyMeasurable f μ) :
snorm f p μ ≤ snorm f q μ * μ Set.univ ^ (1 / p.toReal - 1 / q.toReal) := by |
by_cases hp0 : p = 0
· simp [hp0, zero_le]
rw [← Ne] at hp0
have hp0_lt : 0 < p := lt_of_le_of_ne (zero_le _) hp0.symm
have hq0_lt : 0 < q := lt_of_lt_of_le hp0_lt hpq
by_cases hq_top : q = ∞
· simp only [hq_top, _root_.div_zero, one_div, ENNReal.top_toReal, sub_zero, snorm_exponent_top,
GroupWithZ... | [
" snorm' f p μ ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)",
" ↑‖f a‖₊ ^ p = (↑‖f a‖₊ * g a) ^ p",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ p ∂μ) ^ (1 / p) ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ p ∂μ) ^ (1 / p) ≤ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q) * μ Set.univ ^ (1 / p - 1 / q)",
" (... | [
" snorm' f p μ ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)",
" ↑‖f a‖₊ ^ p = (↑‖f a‖₊ * g a) ^ p",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ p ∂μ) ^ (1 / p) ≤ snorm' f q μ * μ Set.univ ^ (1 / p - 1 / q)",
" (∫⁻ (a : α), ↑‖f a‖₊ ^ p ∂μ) ^ (1 / p) ≤ (∫⁻ (a : α), ↑‖f a‖₊ ^ q ∂μ) ^ (1 / q) * μ Set.univ ^ (1 / p - 1 / q)",
" (... |
import Mathlib.CategoryTheory.Generator
import Mathlib.CategoryTheory.Preadditive.Yoneda.Basic
#align_import category_theory.preadditive.generator from "leanprover-community/mathlib"@"09f981f72d43749f1fa072deade828d9c1e185bb"
universe v u
open CategoryTheory Opposite
namespace CategoryTheory
variable {C : Type... | Mathlib/CategoryTheory/Preadditive/Generator.lean | 77 | 81 | theorem isCoseparator_iff_faithful_preadditiveYonedaObj (G : C) :
IsCoseparator G ↔ (preadditiveYonedaObj G).Faithful := by |
rw [isCoseparator_iff_faithful_preadditiveYoneda, preadditiveYoneda_obj]
exact ⟨fun h => Functor.Faithful.of_comp _ (forget₂ _ AddCommGroupCat.{v}),
fun h => Functor.Faithful.comp _ _⟩
| [
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), (f - g) ≫ h = 0",
" ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ (h : Y ⟶ G), (f - g) ... | [
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), (f - g) ≫ h = 0",
" ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ (h : Y ⟶ G), (f - g) ... |
import Mathlib.Data.Nat.Defs
import Mathlib.Order.Interval.Set.Basic
import Mathlib.Tactic.Monotonicity.Attr
#align_import data.nat.log from "leanprover-community/mathlib"@"3e00d81bdcbf77c8188bbd18f5524ddc3ed8cac6"
namespace Nat
--@[pp_nodot] porting note: unknown attribute
def log (b : ℕ) : ℕ → ℕ
| n => i... | Mathlib/Data/Nat/Log.lean | 114 | 116 | theorem le_log_of_pow_le {b x y : ℕ} (hb : 1 < b) (h : b ^ x ≤ y) : x ≤ log b y := by |
rcases ne_or_eq y 0 with (hy | rfl)
exacts [(pow_le_iff_le_log hb hy).1 h, (h.not_lt (Nat.pow_pos (Nat.zero_lt_one.trans hb))).elim]
| [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 (n / b) a✝",
" b.log n = 0 ↔ n < b ∨ b ≤ 1",
" (∀ (h : b ≤ n ∧ 1 < b), b.log (n / b) + 1 = 0) ↔ n < b ∨ b ≤ 1",
" 0 < b.log n ↔ b ≤ n ∧ 1 < b",
" b.log n = b.log (n / b) + 1",
" (if h : b ≤ n ∧ 1 < b then b.log (n / b) + 1 else 0) = b.log (n / b)... | [
" (invImage (fun x => x) instWellFoundedRelationOfSizeOf).1 (n / b) a✝",
" b.log n = 0 ↔ n < b ∨ b ≤ 1",
" (∀ (h : b ≤ n ∧ 1 < b), b.log (n / b) + 1 = 0) ↔ n < b ∨ b ≤ 1",
" 0 < b.log n ↔ b ≤ n ∧ 1 < b",
" b.log n = b.log (n / b) + 1",
" (if h : b ≤ n ∧ 1 < b then b.log (n / b) + 1 else 0) = b.log (n / b)... |
import Mathlib.Data.Set.Lattice
import Mathlib.Data.Set.Pairwise.Basic
#align_import data.set.pairwise.lattice from "leanprover-community/mathlib"@"c4c2ed622f43768eff32608d4a0f8a6cec1c047d"
open Function Set Order
variable {α β γ ι ι' : Type*} {κ : Sort*} {r p q : α → α → Prop}
section Pairwise
variable {f g : ... | Mathlib/Data/Set/Pairwise/Lattice.lean | 124 | 130 | theorem biUnion_diff_biUnion_eq {s t : Set ι} {f : ι → Set α} (h : (s ∪ t).PairwiseDisjoint f) :
((⋃ i ∈ s, f i) \ ⋃ i ∈ t, f i) = ⋃ i ∈ s \ t, f i := by |
refine
(biUnion_diff_biUnion_subset f s t).antisymm
(iUnion₂_subset fun i hi a ha => (mem_diff _).2 ⟨mem_biUnion hi.1 ha, ?_⟩)
rw [mem_iUnion₂]; rintro ⟨j, hj, haj⟩
exact (h (Or.inl hi.1) (Or.inr hj) (ne_of_mem_of_not_mem hj hi.2).symm).le_bot ⟨ha, haj⟩
| [
" (⋃ i ∈ s, f i) \\ ⋃ i ∈ t, f i = ⋃ i ∈ s \\ t, f i",
" a ∉ ⋃ x ∈ t, f x",
" ¬∃ i, ∃ (_ : i ∈ t), a ∈ f i",
" False"
] | [] |
import Mathlib.Algebra.GCDMonoid.Finset
import Mathlib.Algebra.Polynomial.CancelLeads
import Mathlib.Algebra.Polynomial.EraseLead
import Mathlib.Algebra.Polynomial.FieldDivision
#align_import ring_theory.polynomial.content from "leanprover-community/mathlib"@"7a030ab8eb5d99f05a891dccc49c5b5b90c947d3"
namespace Po... | Mathlib/RingTheory/Polynomial/Content.lean | 83 | 88 | theorem content_dvd_coeff {p : R[X]} (n : ℕ) : p.content ∣ p.coeff n := by |
by_cases h : n ∈ p.support
· apply Finset.gcd_dvd h
rw [mem_support_iff, Classical.not_not] at h
rw [h]
apply dvd_zero
| [
" p.content ∣ p.coeff n",
" p.content ∣ 0"
] | [] |
import Mathlib.Topology.MetricSpace.HausdorffDistance
#align_import topology.metric_space.hausdorff_distance from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
noncomputable section
open NNReal ENNReal Topology Set Filter Bornology
universe u v w
variable {ι : Sort*} {α : Type u} {β :... | Mathlib/Topology/MetricSpace/Thickening.lean | 271 | 275 | theorem closedBall_subset_cthickening_singleton {α : Type*} [PseudoMetricSpace α] (x : α) (δ : ℝ) :
closedBall x δ ⊆ cthickening δ ({x} : Set α) := by |
rcases lt_or_le δ 0 with (hδ | hδ)
· simp only [closedBall_eq_empty.mpr hδ, empty_subset]
· simp only [cthickening_singleton x hδ, Subset.rfl]
| [
" ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E",
" x ∉ cthickening δ E",
" ENNReal.ofReal δ < infEdist x E",
" x ∈ cthickening δ E",
" edist x y ≤ ENNReal.ofReal δ",
" ENNReal.ofReal (dist x y) ≤ ENNReal.ofReal δ",
" cthickening δ ∅ = ∅",
" cthickening δ E = closure E",
" x ∈ cthickening δ E ↔ x ∈ closur... | [
" ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E",
" x ∉ cthickening δ E",
" ENNReal.ofReal δ < infEdist x E",
" x ∈ cthickening δ E",
" edist x y ≤ ENNReal.ofReal δ",
" ENNReal.ofReal (dist x y) ≤ ENNReal.ofReal δ",
" cthickening δ ∅ = ∅",
" cthickening δ E = closure E",
" x ∈ cthickening δ E ↔ x ∈ closur... |
import Mathlib.Data.Finset.Sigma
import Mathlib.Data.Finset.Pairwise
import Mathlib.Data.Finset.Powerset
import Mathlib.Data.Fintype.Basic
import Mathlib.Order.CompleteLatticeIntervals
#align_import order.sup_indep from "leanprover-community/mathlib"@"c4c2ed622f43768eff32608d4a0f8a6cec1c047d"
variable {α β ι ι' :... | Mathlib/Order/SupIndep.lean | 106 | 117 | theorem SupIndep.image [DecidableEq ι] {s : Finset ι'} {g : ι' → ι} (hs : s.SupIndep (f ∘ g)) :
(s.image g).SupIndep f := by |
intro t ht i hi hit
rw [mem_image] at hi
obtain ⟨i, hi, rfl⟩ := hi
haveI : DecidableEq ι' := Classical.decEq _
suffices hts : t ⊆ (s.erase i).image g by
refine (supIndep_iff_disjoint_erase.1 hs i hi).mono_right ((sup_mono hts).trans ?_)
rw [sup_image]
rintro j hjt
obtain ⟨j, hj, rfl⟩ := mem_image... | [
" Decidable (s.SupIndep f)",
" (t : Finset ι) → t ⊆ s → Decidable (∀ ⦃i : ι⦄, i ∈ s → i ∉ t → Disjoint (f i) (t.sup f))",
" Decidable (∀ ⦃i : ι⦄, i ∈ s → i ∉ t → Disjoint (f i) (t.sup f))",
" (a : ι) → a ∈ s → Decidable (a ∉ t → Disjoint (f a) (t.sup f))",
" Decidable (i ∉ t → Disjoint (f i) (t.sup f))",
... | [
" Decidable (s.SupIndep f)",
" (t : Finset ι) → t ⊆ s → Decidable (∀ ⦃i : ι⦄, i ∈ s → i ∉ t → Disjoint (f i) (t.sup f))",
" Decidable (∀ ⦃i : ι⦄, i ∈ s → i ∉ t → Disjoint (f i) (t.sup f))",
" (a : ι) → a ∈ s → Decidable (a ∉ t → Disjoint (f a) (t.sup f))",
" Decidable (i ∉ t → Disjoint (f i) (t.sup f))",
... |
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 | 154 | 154 | theorem fst_map (x : P α) (f : α → β) : (P.map f x).1 = x.1 := by | cases x; rfl
| [
" (mk p).dest = p",
" (mk ⟨fst✝, snd✝⟩).dest = ⟨fst✝, snd✝⟩",
" mk p.dest = p",
" mk (dest (WType.mk a✝ f✝)) = WType.mk a✝ f✝",
" (P.map f x).fst = x.fst",
" (P.map f ⟨fst✝, snd✝⟩).fst = ⟨fst✝, snd✝⟩.fst"
] | [
" (mk p).dest = p",
" (mk ⟨fst✝, snd✝⟩).dest = ⟨fst✝, snd✝⟩",
" mk p.dest = p",
" mk (dest (WType.mk a✝ f✝)) = WType.mk a✝ f✝"
] |
import Mathlib.Algebra.Homology.ComplexShape
import Mathlib.CategoryTheory.Subobject.Limits
import Mathlib.CategoryTheory.GradedObject
import Mathlib.Algebra.Homology.ShortComplex.Basic
#align_import algebra.homology.homological_complex from "leanprover-community/mathlib"@"88bca0ce5d22ebfd9e73e682e51d60ea13b48347"
... | Mathlib/Algebra/Homology/HomologicalComplex.lean | 79 | 92 | theorem ext {C₁ C₂ : HomologicalComplex V c} (h_X : C₁.X = C₂.X)
(h_d :
∀ i j : ι,
c.Rel i j → C₁.d i j ≫ eqToHom (congr_fun h_X j) = eqToHom (congr_fun h_X i) ≫ C₂.d i j) :
C₁ = C₂ := by |
obtain ⟨X₁, d₁, s₁, h₁⟩ := C₁
obtain ⟨X₂, d₂, s₂, h₂⟩ := C₂
dsimp at h_X
subst h_X
simp only [mk.injEq, heq_eq_eq, true_and]
ext i j
by_cases hij: c.Rel i j
· simpa only [comp_id, id_comp, eqToHom_refl] using h_d i j hij
· rw [s₁ i j hij, s₂ i j hij]
| [
" C.d i j ≫ C.d j k = 0",
" C₁ = C₂",
" { X := X₁, d := d₁, shape := s₁, d_comp_d' := h₁ } = C₂",
" { X := X₁, d := d₁, shape := s₁, d_comp_d' := h₁ } = { X := X₂, d := d₂, shape := s₂, d_comp_d' := h₂ }",
" { X := X₁, d := d₁, shape := s₁, d_comp_d' := h₁ } = { X := X₁, d := d₂, shape := s₂, d_comp_d' := h... | [
" C.d i j ≫ C.d j k = 0"
] |
import Mathlib.Analysis.Calculus.Deriv.Basic
import Mathlib.Analysis.Calculus.ContDiff.Defs
#align_import analysis.calculus.iterated_deriv from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open scoped Classical Topology
open Filter Asymptotics Set
variable {𝕜... | Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean | 151 | 154 | theorem ContDiffOn.continuousOn_iteratedDerivWithin {n : ℕ∞} {m : ℕ} (h : ContDiffOn 𝕜 n f s)
(hmn : (m : ℕ∞) ≤ n) (hs : UniqueDiffOn 𝕜 s) : ContinuousOn (iteratedDerivWithin m f s) s := by |
simpa only [iteratedDerivWithin_eq_equiv_comp, LinearIsometryEquiv.comp_continuousOn_iff] using
h.continuousOn_iteratedFDerivWithin hmn hs
| [
" iteratedDerivWithin n f univ = iteratedDeriv n f",
" iteratedDerivWithin n f univ x = iteratedDeriv n f x",
" iteratedDerivWithin n f s = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDerivWithin 𝕜 n f s",
" iteratedDerivWithin n f s x =\n (⇑(ContinuousMultilinearMap.piFieldEquiv... | [
" iteratedDerivWithin n f univ = iteratedDeriv n f",
" iteratedDerivWithin n f univ x = iteratedDeriv n f x",
" iteratedDerivWithin n f s = ⇑(ContinuousMultilinearMap.piFieldEquiv 𝕜 (Fin n) F).symm ∘ iteratedFDerivWithin 𝕜 n f s",
" iteratedDerivWithin n f s x =\n (⇑(ContinuousMultilinearMap.piFieldEquiv... |
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.LinearAlgebra.AffineSpace.Ordered
import Mathlib.Topology.ContinuousFunction.Basic
import Mathlib.Topology.GDelta
import Mathlib.Analysis.NormedSpace.FunctionSeries
import Mathlib.Analysis.SpecificLimits.Basic
#align_import topology.urysohns_lemma from "lea... | Mathlib/Topology/UrysohnsLemma.lean | 169 | 175 | theorem approx_of_nmem_U (c : CU P) (n : ℕ) {x : X} (hx : x ∉ c.U) : c.approx n x = 1 := by |
induction' n with n ihn generalizing c
· rw [← mem_compl_iff] at hx
exact indicator_of_mem hx _
· simp only [approx]
rw [ihn, ihn, midpoint_self]
exacts [hx, fun hU => hx <| c.left_U_subset hU]
| [
" approx n c x = 0",
" approx 0 c x = 0",
" approx (n + 1) c x = 0",
" midpoint ℝ (approx n c.left x) (approx n c.right x) = 0",
" x ∈ c.left.C",
" approx n c x = 1",
" approx 0 c x = 1",
" approx (n + 1) c x = 1",
" midpoint ℝ (approx n c.left x) (approx n c.right x) = 1",
" x ∉ c.left.U"
] | [
" approx n c x = 0",
" approx 0 c x = 0",
" approx (n + 1) c x = 0",
" midpoint ℝ (approx n c.left x) (approx n c.right x) = 0",
" x ∈ c.left.C"
] |
import Mathlib.LinearAlgebra.QuadraticForm.TensorProduct
import Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv
suppress_compilation
universe uR uM₁ uM₂ uM₃ uM₄
variable {R : Type uR} {M₁ : Type uM₁} {M₂ : Type uM₂} {M₃ : Type uM₃} {M₄ : Type uM₄}
open scoped TensorProduct
namespace QuadraticForm
variable [Co... | Mathlib/LinearAlgebra/QuadraticForm/TensorProduct/Isometries.lean | 186 | 192 | theorem comp_tensorLId_eq (Q₂ : QuadraticForm R M₂) :
Q₂.comp (TensorProduct.lid R M₂) = (sq (R := R)).tmul Q₂ := by |
refine (QuadraticForm.associated_rightInverse R).injective ?_
ext m₂ m₂'
dsimp [-associated_apply]
simp only [associated_tmul, QuadraticForm.associated_comp]
simp [-associated_apply, mul_one]
| [
" (Q₂.tmul Q₄).comp (TensorProduct.map f.toLinearMap g.toLinearMap) = Q₁.tmul Q₃",
" (associatedHom R) ((Q₂.tmul Q₄).comp (TensorProduct.map f.toLinearMap g.toLinearMap)) = (associatedHom R) (Q₁.tmul Q₃)",
" ((TensorProduct.AlgebraTensorModule.curry\n (((TensorProduct.AlgebraTensorModule.curry\n ... | [
" (Q₂.tmul Q₄).comp (TensorProduct.map f.toLinearMap g.toLinearMap) = Q₁.tmul Q₃",
" (associatedHom R) ((Q₂.tmul Q₄).comp (TensorProduct.map f.toLinearMap g.toLinearMap)) = (associatedHom R) (Q₁.tmul Q₃)",
" ((TensorProduct.AlgebraTensorModule.curry\n (((TensorProduct.AlgebraTensorModule.curry\n ... |
import Mathlib.LinearAlgebra.Eigenspace.Basic
import Mathlib.FieldTheory.IsAlgClosed.Spectrum
#align_import linear_algebra.eigenspace.is_alg_closed from "leanprover-community/mathlib"@"6b0169218d01f2837d79ea2784882009a0da1aa1"
open Set Function Module FiniteDimensional
variable {K V : Type*} [Field K] [AddCommGro... | Mathlib/LinearAlgebra/Eigenspace/Triangularizable.lean | 132 | 192 | theorem inf_iSup_genEigenspace [FiniteDimensional K V] (h : ∀ x ∈ p, f x ∈ p) :
p ⊓ ⨆ μ, ⨆ k, f.genEigenspace μ k = ⨆ μ, ⨆ k, p ⊓ f.genEigenspace μ k := by |
simp_rw [← (f.genEigenspace _).mono.directed_le.inf_iSup_eq]
refine le_antisymm (fun m hm ↦ ?_)
(le_inf_iff.mpr ⟨iSup_le fun μ ↦ inf_le_left, iSup_mono fun μ ↦ inf_le_right⟩)
classical
obtain ⟨hm₀ : m ∈ p, hm₁ : m ∈ ⨆ μ, ⨆ k, f.genEigenspace μ k⟩ := hm
obtain ⟨m, hm₂, rfl⟩ := (mem_iSup_iff_exists_finsupp... | [
" p ⊓ ⨆ μ, ⨆ k, (f.genEigenspace μ) k = ⨆ μ, ⨆ k, p ⊓ (f.genEigenspace μ) k",
" p ⊓ ⨆ μ, ⨆ k, (f.genEigenspace μ) k = ⨆ μ, p ⊓ ⨆ i, (f.genEigenspace μ) i",
" m ∈ ⨆ μ, p ⊓ ⨆ i, (f.genEigenspace μ) i",
" (m.sum fun _i xi => xi) ∈ ⨆ μ, p ⊓ ⨆ i, (f.genEigenspace μ) i",
" ∀ (μ : K), m μ ∈ p",
" m μ ∈ p",
" g... | [] |
import Mathlib.Data.Matrix.Basic
variable {l m n o : Type*}
universe u v w
variable {R : Type*} {α : Type v} {β : Type w}
namespace Matrix
def col (w : m → α) : Matrix m Unit α :=
of fun x _ => w x
#align matrix.col Matrix.col
-- TODO: set as an equation lemma for `col`, see mathlib4#3024
@[simp]
theorem col... | Mathlib/Data/Matrix/RowCol.lean | 88 | 90 | theorem row_smul [SMul R α] (x : R) (v : m → α) : row (x • v) = x • row v := by |
ext
rfl
| [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝",
" col (x • v) = x • col v",
" col (x • v) i✝ j✝ = (x • col v) i✝ j✝",
" row (v + w) = row v + row w",
" row (v + w) i✝ j✝ = (row v + row w) i✝ j✝",
" row (x • v) = x • row v",
" row (x • v) i✝ j✝ = (x • row v) i✝ j✝"
] | [
" col (v + w) = col v + col w",
" col (v + w) i✝ j✝ = (col v + col w) i✝ j✝",
" col (x • v) = x • col v",
" col (x • v) i✝ j✝ = (x • col v) i✝ j✝",
" row (v + w) = row v + row w",
" row (v + w) i✝ j✝ = (row v + row w) i✝ j✝"
] |
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 | 456 | 457 | theorem mul_div_assoc (a b c : G) : a * b / c = a * (b / c) := by |
rw [div_eq_mul_inv, div_eq_mul_inv, mul_assoc _ _ _]
| [
" x⁻¹ = 1 / x",
" x * (1 / y) = x / y",
" a * b / c = a * (b / c)"
] | [
" x⁻¹ = 1 / x",
" x * (1 / y) = x / y"
] |
import Mathlib.Data.Fintype.List
#align_import data.list.cycle from "leanprover-community/mathlib"@"7413128c3bcb3b0818e3e18720abc9ea3100fb49"
assert_not_exists MonoidWithZero
namespace List
variable {α : Type*} [DecidableEq α]
def nextOr : ∀ (_ : List α) (_ _ : α), α
| [], _, default => default
| [_], _, d... | Mathlib/Data/List/Cycle.lean | 87 | 91 | theorem nextOr_concat {xs : List α} {x : α} (d : α) (h : x ∉ xs) : nextOr (xs ++ [x]) x d = d := by |
induction' xs with z zs IH
· simp
· obtain ⟨hz, hzs⟩ := not_or.mp (mt mem_cons.2 h)
rw [cons_append, nextOr_cons_of_ne _ _ _ _ hz, IH hzs]
| [
" (y :: xs).nextOr x d = xs.nextOr x d",
" [y].nextOr x d = [].nextOr x d",
" (y :: z :: zs).nextOr x d = (z :: zs).nextOr x d",
" xs.nextOr x d = xs.nextOr x d'",
" [].nextOr x d = [].nextOr x d'",
" (y :: ys).nextOr x d = (y :: ys).nextOr x d'",
" [y].nextOr x d = [y].nextOr x d'",
" (y :: z :: zs).... | [
" (y :: xs).nextOr x d = xs.nextOr x d",
" [y].nextOr x d = [].nextOr x d",
" (y :: z :: zs).nextOr x d = (z :: zs).nextOr x d",
" xs.nextOr x d = xs.nextOr x d'",
" [].nextOr x d = [].nextOr x d'",
" (y :: ys).nextOr x d = (y :: ys).nextOr x d'",
" [y].nextOr x d = [y].nextOr x d'",
" (y :: z :: zs).... |
import Mathlib.Analysis.Convex.Cone.Extension
import Mathlib.Analysis.NormedSpace.RCLike
import Mathlib.Analysis.NormedSpace.Extend
import Mathlib.Analysis.RCLike.Lemmas
#align_import analysis.normed_space.hahn_banach.extension from "leanprover-community/mathlib"@"915591b2bb3ea303648db07284a161a7f2a9e3d4"
univers... | Mathlib/Analysis/NormedSpace/HahnBanach/Extension.lean | 151 | 163 | theorem coord_norm' {x : E} (h : x ≠ 0) : ‖(‖x‖ : 𝕜) • coord 𝕜 x h‖ = 1 := by |
#adaptation_note
/--
`set_option maxSynthPendingDepth 2` required after https://github.com/leanprover/lean4/pull/4119
Alternatively, we can add:
```
let X : SeminormedAddCommGroup (↥(span 𝕜 {x}) →L[𝕜] 𝕜) := inferInstance
have : BoundedSMul 𝕜 (↥(span 𝕜 {x}) →L[𝕜] 𝕜) := @NormedSpace.boundedSMul 𝕜 _... | [
" ‖↑‖x‖ • coord 𝕜 x h‖ = 1"
] | [] |
import Mathlib.Topology.Algebra.UniformConvergence
#align_import topology.algebra.module.strong_topology from "leanprover-community/mathlib"@"8905e5ed90859939681a725b00f6063e65096d95"
open scoped Topology UniformConvergence
section General
variable {𝕜₁ 𝕜₂ : Type*} [NormedField 𝕜₁] [NormedField 𝕜₂] (σ : 𝕜... | Mathlib/Topology/Algebra/Module/StrongTopology.lean | 152 | 157 | theorem t2Space [TopologicalSpace F] [TopologicalAddGroup F] [T2Space F]
(𝔖 : Set (Set E)) (h𝔖 : ⋃₀ 𝔖 = Set.univ) : T2Space (UniformConvergenceCLM σ F 𝔖) := by |
letI : UniformSpace F := TopologicalAddGroup.toUniformSpace F
haveI : UniformAddGroup F := comm_topologicalAddGroup_is_uniform
haveI : T2Space (E →ᵤ[𝔖] F) := UniformOnFun.t2Space_of_covering h𝔖
exact (embedding_coeFn σ F 𝔖).t2Space
| [
" instTopologicalSpace σ F 𝔖 = TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖)",
" TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖) =\n TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖)",
" TopologicalAddGroup.toUniformSpace... | [
" instTopologicalSpace σ F 𝔖 = TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖)",
" TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖) =\n TopologicalSpace.induced DFunLike.coe (UniformOnFun.topologicalSpace E F 𝔖)",
" TopologicalAddGroup.toUniformSpace... |
import Mathlib.MeasureTheory.PiSystem
import Mathlib.Order.OmegaCompletePartialOrder
import Mathlib.Topology.Constructions
import Mathlib.MeasureTheory.MeasurableSpace.Basic
open Set
namespace MeasureTheory
variable {ι : Type _} {α : ι → Type _}
section cylinder
def cylinder (s : Finset ι) (S : Set (∀ i : s, α... | Mathlib/MeasureTheory/Constructions/Cylinders.lean | 165 | 166 | theorem cylinder_univ (s : Finset ι) : cylinder s (univ : Set (∀ i : s, α i)) = univ := by |
rw [cylinder, preimage_univ]
| [
" cylinder s ∅ = ∅",
" cylinder s univ = univ"
] | [
" cylinder s ∅ = ∅"
] |
import Mathlib.Order.Ideal
import Mathlib.Order.PFilter
#align_import order.prime_ideal from "leanprover-community/mathlib"@"740acc0e6f9adf4423f92a485d0456fc271482da"
open Order.PFilter
namespace Order
variable {P : Type*}
namespace Ideal
-- Porting note(#5171): this linter isn't ported yet.
-- @[nolint has_... | Mathlib/Order/PrimeIdeal.lean | 131 | 139 | theorem IsPrime.of_mem_or_mem [IsProper I] (hI : ∀ {x y : P}, x ⊓ y ∈ I → x ∈ I ∨ y ∈ I) :
IsPrime I := by |
rw [isPrime_iff]
use ‹_›
refine .of_def ?_ ?_ ?_
· exact Set.nonempty_compl.2 (I.isProper_iff.1 ‹_›)
· intro x hx y hy
exact ⟨x ⊓ y, fun h => (hI h).elim hx hy, inf_le_left, inf_le_right⟩
· exact @mem_compl_of_ge _ _ _
| [
" x ⊓ y ∈ I → x ∈ I ∨ y ∈ I",
" x ∉ I ∧ y ∉ I → x ⊓ y ∉ I",
" x ∈ F ∧ y ∈ F → x ⊓ y ∈ F",
" I.IsPrime",
" I.IsProper ∧ IsPFilter (↑I)ᶜ",
" IsPFilter (↑I)ᶜ",
" (↑I)ᶜ.Nonempty",
" DirectedOn (fun x x_1 => x ≥ x_1) (↑I)ᶜ",
" ∃ z ∈ (↑I)ᶜ, (fun x x_1 => x ≥ x_1) x z ∧ (fun x x_1 => x ≥ x_1) y z",
" ∀ {... | [
" x ⊓ y ∈ I → x ∈ I ∨ y ∈ I",
" x ∉ I ∧ y ∉ I → x ⊓ y ∉ I",
" x ∈ F ∧ y ∈ F → x ⊓ y ∈ F"
] |
import Mathlib.CategoryTheory.Generator
import Mathlib.CategoryTheory.Preadditive.Yoneda.Basic
#align_import category_theory.preadditive.generator from "leanprover-community/mathlib"@"09f981f72d43749f1fa072deade828d9c1e185bb"
universe v u
open CategoryTheory Opposite
namespace CategoryTheory
variable {C : Type... | Mathlib/CategoryTheory/Preadditive/Generator.lean | 69 | 74 | theorem isCoseparator_iff_faithful_preadditiveYoneda (G : C) :
IsCoseparator G ↔ (preadditiveYoneda.obj G).Faithful := by |
rw [isCoseparator_iff_faithful_yoneda_obj, ← whiskering_preadditiveYoneda, Functor.comp_obj,
whiskeringRight_obj_obj]
exact ⟨fun h => Functor.Faithful.of_comp _ (forget AddCommGroupCat),
fun h => Functor.Faithful.comp _ _⟩
| [
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), (f - g) ≫ h = 0",
" ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ (h : Y ⟶ G), (f - g) ... | [
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ G ∈ 𝒢, ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ G ∈ 𝒢, ∀ (h : Y ⟶ G), (f - g) ≫ h = 0",
" ∀ (h : G ⟶ X), h ≫ f = h ≫ 0",
" ∀ (h : G ⟶ X), h ≫ (f - g) = 0",
" ∀ (h : Y ⟶ G), f ≫ h = 0 ≫ h",
" ∀ (h : Y ⟶ G), (f - g) ... |
import Mathlib.Tactic.Ring
#align_import algebra.group_power.identities from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
variable {R : Type*} [CommRing R] {a b x₁ x₂ x₃ x₄ x₅ x₆ x₇ x₈ y₁ y₂ y₃ y₄ y₅ y₆ y₇ y₈ n : R}
| Mathlib/Algebra/Ring/Identities.lean | 24 | 26 | theorem sq_add_sq_mul_sq_add_sq :
(x₁ ^ 2 + x₂ ^ 2) * (y₁ ^ 2 + y₂ ^ 2) = (x₁ * y₁ - x₂ * y₂) ^ 2 + (x₁ * y₂ + x₂ * y₁) ^ 2 := by |
ring
| [
" (x₁ ^ 2 + x₂ ^ 2) * (y₁ ^ 2 + y₂ ^ 2) = (x₁ * y₁ - x₂ * y₂) ^ 2 + (x₁ * y₂ + x₂ * y₁) ^ 2"
] | [] |
import Mathlib.Analysis.InnerProductSpace.GramSchmidtOrtho
import Mathlib.LinearAlgebra.Orientation
#align_import analysis.inner_product_space.orientation from "leanprover-community/mathlib"@"bd65478311e4dfd41f48bf38c7e3b02fb75d0163"
noncomputable section
variable {E : Type*} [NormedAddCommGroup E] [InnerProduct... | Mathlib/Analysis/InnerProductSpace/Orientation.lean | 141 | 143 | theorem abs_det_adjustToOrientation (v : ι → E) :
|(e.adjustToOrientation x).toBasis.det v| = |e.toBasis.det v| := by |
simp [toBasis_adjustToOrientation]
| [
" e.toBasis.det ⇑f = 1",
" ¬e.toBasis.det ⇑f = -1",
" 0 < e.toBasis.det ⇑f",
" e.toBasis.det ⇑f = -1",
" e.toBasis.orientation = f.toBasis.orientation",
" e.toBasis.det = f.toBasis.det ↔ e.toBasis.orientation = f.toBasis.orientation",
" e.toBasis.det = f.toBasis.det → e.toBasis.orientation = f.toBasis.o... | [
" e.toBasis.det ⇑f = 1",
" ¬e.toBasis.det ⇑f = -1",
" 0 < e.toBasis.det ⇑f",
" e.toBasis.det ⇑f = -1",
" e.toBasis.orientation = f.toBasis.orientation",
" e.toBasis.det = f.toBasis.det ↔ e.toBasis.orientation = f.toBasis.orientation",
" e.toBasis.det = f.toBasis.det → e.toBasis.orientation = f.toBasis.o... |
import Mathlib.Algebra.Group.Subgroup.Basic
import Mathlib.CategoryTheory.Groupoid.VertexGroup
import Mathlib.CategoryTheory.Groupoid.Basic
import Mathlib.CategoryTheory.Groupoid
import Mathlib.Data.Set.Lattice
import Mathlib.Order.GaloisConnection
#align_import category_theory.groupoid.subgroupoid from "leanprover-c... | Mathlib/CategoryTheory/Groupoid/Subgroupoid.lean | 100 | 107 | theorem mul_mem_cancel_right {c d e : C} {f : c ⟶ d} {g : d ⟶ e} (hg : g ∈ S.arrows d e) :
f ≫ g ∈ S.arrows c e ↔ f ∈ S.arrows c d := by |
constructor
· rintro h
suffices (f ≫ g) ≫ Groupoid.inv g ∈ S.arrows c d by
simpa only [inv_eq_inv, IsIso.hom_inv_id, Category.comp_id, Category.assoc] using this
apply S.mul h (S.inv hg)
· exact fun hf => S.mul hf hg
| [
" Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d",
" Groupoid.inv f ∈ S.arrows d c → f ∈ S.arrows c d",
" f ∈ S.arrows c d",
" f ∈ S.arrows c d → Groupoid.inv f ∈ S.arrows d c",
" f ≫ g ∈ S.arrows c e ↔ g ∈ S.arrows d e",
" f ≫ g ∈ S.arrows c e → g ∈ S.arrows d e",
" g ∈ S.arrows d e",
" Groupoid.in... | [
" Groupoid.inv f ∈ S.arrows d c ↔ f ∈ S.arrows c d",
" Groupoid.inv f ∈ S.arrows d c → f ∈ S.arrows c d",
" f ∈ S.arrows c d",
" f ∈ S.arrows c d → Groupoid.inv f ∈ S.arrows d c",
" f ≫ g ∈ S.arrows c e ↔ g ∈ S.arrows d e",
" f ≫ g ∈ S.arrows c e → g ∈ S.arrows d e",
" g ∈ S.arrows d e",
" Groupoid.in... |
import Mathlib.Analysis.SpecialFunctions.ImproperIntegrals
import Mathlib.Analysis.Calculus.ParametricIntegral
import Mathlib.MeasureTheory.Measure.Haar.NormedSpace
#align_import analysis.mellin_transform from "leanprover-community/mathlib"@"917c3c072e487b3cccdbfeff17e75b40e45f66cb"
open MeasureTheory Set Filter A... | Mathlib/Analysis/MellinTransform.lean | 106 | 109 | theorem mellin_cpow_smul (f : ℝ → E) (s a : ℂ) :
mellin (fun t => (t : ℂ) ^ a • f t) s = mellin f (s + a) := by |
refine setIntegral_congr measurableSet_Ioi fun t ht => ?_
simp_rw [← sub_add_eq_add_sub, cpow_add _ _ (ofReal_ne_zero.2 <| ne_of_gt ht), mul_smul]
| [
" MellinConvergent (fun t => c • f t) s",
" MellinConvergent (fun t => ↑t ^ a • f t) s ↔ MellinConvergent f (s + a)",
" ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t",
" MellinConvergent (fun t => f t / a) s",
" MellinConvergent (fun t => f (a * t)) s ↔ MellinConvergent f s",
" (fun t ... | [
" MellinConvergent (fun t => c • f t) s",
" MellinConvergent (fun t => ↑t ^ a • f t) s ↔ MellinConvergent f (s + a)",
" ↑t ^ (s - 1) • (fun t => ↑t ^ a • f t) t = ↑t ^ (s + a - 1) • f t",
" MellinConvergent (fun t => f t / a) s",
" MellinConvergent (fun t => f (a * t)) s ↔ MellinConvergent f s",
" (fun t ... |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Algebra.Order.Group.Indicator
import Mathlib.Order.LiminfLimsup
import Mathlib.Order.Filter.Archimedean
import Mathlib.Order.Filter.CountableInter
import Mathlib.Topology.Algebra.Group.Basic
import Mathlib.Data.Set.La... | Mathlib/Topology/Algebra/Order/LiminfLimsup.lean | 476 | 479 | theorem iInf_eq_of_forall_le_of_tendsto {x : R} {as : ι → R} (x_le : ∀ i, x ≤ as i) {F : Filter ι}
[Filter.NeBot F] (as_lim : Filter.Tendsto as F (𝓝 x)) : ⨅ i, as i = x := by |
refine iInf_eq_of_forall_ge_of_forall_gt_exists_lt (fun i ↦ x_le i) ?_
apply fun w x_lt_w ↦ ‹Filter.NeBot F›.nonempty_of_mem (eventually_lt_of_tendsto_lt x_lt_w as_lim)
| [
" ⨅ i, as i = x",
" ∀ (w : R), x < w → ∃ i, as i < w"
] | [] |
import Mathlib.Analysis.Convex.Between
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.Topology.MetricSpace.Holder
import Mathlib.Topology.MetricSpace.MetricSeparated
#align_import measure_theory.measure.hausdorff from "leanprover-communit... | Mathlib/MeasureTheory/Measure/Hausdorff.lean | 286 | 290 | theorem tendsto_pre (m : Set X → ℝ≥0∞) (s : Set X) :
Tendsto (fun r => pre m r s) (𝓝[>] 0) (𝓝 <| mkMetric' m s) := by |
rw [← map_coe_Ioi_atBot, tendsto_map'_iff]
simp only [mkMetric', OuterMeasure.iSup_apply, iSup_subtype']
exact tendsto_atBot_iSup fun r r' hr => mono_pre _ hr _
| [
" μ ≤ pre m r ↔ ∀ (s : Set X), diam s ≤ r → μ s ≤ m s",
" (↑l)⁻¹ ≤ (↑k)⁻¹",
" Tendsto (fun r => (pre m r) s) (𝓝[>] 0) (𝓝 ((mkMetric' m) s))",
" Tendsto ((fun r => (pre m r) s) ∘ Subtype.val) atBot (𝓝 ((mkMetric' m) s))",
" Tendsto ((fun r => (pre m r) s) ∘ Subtype.val) atBot (𝓝 (⨆ i, (pre m ↑i) s))"
] | [
" μ ≤ pre m r ↔ ∀ (s : Set X), diam s ≤ r → μ s ≤ m s",
" (↑l)⁻¹ ≤ (↑k)⁻¹"
] |
import Mathlib.Order.RelClasses
#align_import data.sigma.lex from "leanprover-community/mathlib"@"41cf0cc2f528dd40a8f2db167ea4fb37b8fde7f3"
namespace Sigma
variable {ι : Type*} {α : ι → Type*} {r r₁ r₂ : ι → ι → Prop} {s s₁ s₂ : ∀ i, α i → α i → Prop}
{a b : Σ i, α i}
inductive Lex (r : ι → ι → Prop) (s : ∀ ... | Mathlib/Data/Sigma/Lex.lean | 63 | 67 | theorem Lex.mono (hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ i, α i}
(h : Lex r₁ s₁ a b) : Lex r₂ s₂ a b := by |
obtain ⟨a, b, hij⟩ | ⟨a, b, hab⟩ := h
· exact Lex.left _ _ (hr _ _ hij)
· exact Lex.right _ _ (hs _ _ _ hab)
| [
" Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" r ⟨i✝, a⟩.fst ⟨j✝, b⟩.fst ∨ ∃ h, s ⟨j✝, b⟩.fst (h ▸ ⟨i✝, a⟩.snd) ⟨j✝, b⟩.snd",
" r ⟨i✝, a⟩.fst ⟨i✝, b⟩.fst ∨ ∃ h, s ⟨i✝, b⟩.fst (h ▸ ⟨i✝, a⟩.snd) ⟨i✝, b⟩.snd",
" (r a.fst b.fst... | [
" Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" r ⟨i✝, a⟩.fst ⟨j✝, b⟩.fst ∨ ∃ h, s ⟨j✝, b⟩.fst (h ▸ ⟨i✝, a⟩.snd) ⟨j✝, b⟩.snd",
" r ⟨i✝, a⟩.fst ⟨i✝, b⟩.fst ∨ ∃ h, s ⟨i✝, b⟩.fst (h ▸ ⟨i✝, a⟩.snd) ⟨i✝, b⟩.snd",
" (r a.fst b.fst... |
import Mathlib.Analysis.NormedSpace.AffineIsometry
import Mathlib.Topology.Algebra.ContinuousAffineMap
import Mathlib.Analysis.NormedSpace.OperatorNorm.NormedSpace
#align_import analysis.normed_space.continuous_affine_map from "leanprover-community/mathlib"@"17ef379e997badd73e5eabb4d38f11919ab3c4b3"
namespace Con... | Mathlib/Analysis/NormedSpace/ContinuousAffineMap.lean | 102 | 114 | theorem contLinear_eq_zero_iff_exists_const (f : P →ᴬ[R] Q) :
f.contLinear = 0 ↔ ∃ q, f = const R P q := by |
have h₁ : f.contLinear = 0 ↔ (f : P →ᵃ[R] Q).linear = 0 := by
refine ⟨fun h => ?_, fun h => ?_⟩ <;> ext
· rw [← coe_contLinear_eq_linear, h]; rfl
· rw [← coe_linear_eq_coe_contLinear, h]; rfl
have h₂ : ∀ q : Q, f = const R P q ↔ (f : P →ᵃ[R] Q) = AffineMap.const R P q := by
intro q
refine ⟨fun ... | [
" Continuous { toFun := ⇑f.linear, map_add' := ⋯, map_smul' := ⋯ }.toFun",
" Continuous ⇑f.toAffineMap",
" ↑f.contLinear = f.linear",
" ↑f.contLinear x✝ = f.linear x✝",
" f.contLinear = 0 ↔ ∃ q, f = const R P q",
" f.contLinear = 0 ↔ f.linear = 0",
" f.linear = 0",
" f.contLinear = 0",
" f.linear x✝... | [
" Continuous { toFun := ⇑f.linear, map_add' := ⋯, map_smul' := ⋯ }.toFun",
" Continuous ⇑f.toAffineMap",
" ↑f.contLinear = f.linear",
" ↑f.contLinear x✝ = f.linear x✝"
] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.LinearAlgebra.GeneralLinearGroup
import Mathlib.LinearAlgebra.Matrix.Reindex
import Mathlib.Tactic.FieldSimp
import Mathlib.LinearAlgebra.Matrix.NonsingularInverse
import Mathlib.LinearAlgebra.Matrix.Basis
#align_import linear_algebra.determinant from "lea... | Mathlib/LinearAlgebra/Determinant.lean | 83 | 90 | theorem det_comm' [DecidableEq m] [DecidableEq n] {M : Matrix n m A} {N : Matrix m n A}
{M' : Matrix m n A} (hMM' : M * M' = 1) (hM'M : M' * M = 1) : det (M * N) = det (N * M) := by |
nontriviality A
-- Although `m` and `n` are different a priori, we will show they have the same cardinality.
-- This turns the problem into one for square matrices, which is easy.
let e := indexEquivOfInv hMM' hM'M
rw [← det_submatrix_equiv_self e, ← submatrix_mul_equiv _ _ _ (Equiv.refl n) _, det_comm,
... | [
" (M * N).det = (N * M).det"
] | [
" (M * N).det = (N * M).det"
] |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Inverse
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv
#align_import analysis.special_functions.trigonometric.inverse_deriv from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
open scoped Classic... | Mathlib/Analysis/SpecialFunctions/Trigonometric/InverseDeriv.lean | 30 | 49 | theorem deriv_arcsin_aux {x : ℝ} (h₁ : x ≠ -1) (h₂ : x ≠ 1) :
HasStrictDerivAt arcsin (1 / √(1 - x ^ 2)) x ∧ ContDiffAt ℝ ⊤ arcsin x := by |
cases' h₁.lt_or_lt with h₁ h₁
· have : 1 - x ^ 2 < 0 := by nlinarith [h₁]
rw [sqrt_eq_zero'.2 this.le, div_zero]
have : arcsin =ᶠ[𝓝 x] fun _ => -(π / 2) :=
(gt_mem_nhds h₁).mono fun y hy => arcsin_of_le_neg_one hy.le
exact ⟨(hasStrictDerivAt_const _ _).congr_of_eventuallyEq this.symm,
cont... | [
" HasStrictDerivAt arcsin (1 / √(1 - x ^ 2)) x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 1 - x ^ 2 < 0",
" HasStrictDerivAt arcsin 0 x ∧ ContDiffAt ℝ ⊤ arcsin x",
" 0 < 1 - x ^ 2",
" HasStrictDerivAt arcsin x.arcsin.cos⁻¹ x ∧ ContDiffAt ℝ ⊤ arcsin x"
] | [] |
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.MeasureTheory.Function.SimpleFunc
import Mathlib.MeasureTheory.Measure.MutuallySingular
import Mathlib.MeasureTheory.Measure.Count
import Mathlib.Topology.IndicatorConstPointwise
import Mathlib.MeasureTheory.Constructions.BorelSpace.Real
#align_import m... | Mathlib/MeasureTheory/Integral/Lebesgue.lean | 82 | 86 | theorem SimpleFunc.lintegral_eq_lintegral {m : MeasurableSpace α} (f : α →ₛ ℝ≥0∞) (μ : Measure α) :
∫⁻ a, f a ∂μ = f.lintegral μ := by |
rw [MeasureTheory.lintegral]
exact le_antisymm (iSup₂_le fun g hg => lintegral_mono hg <| le_rfl)
(le_iSup₂_of_le f le_rfl le_rfl)
| [
" ∫⁻ (a : α), ↑f a ∂μ = f.lintegral μ",
" ⨆ g, ⨆ (_ : ↑g ≤ fun a => ↑f a), g.lintegral μ = f.lintegral μ"
] | [] |
import Mathlib.Combinatorics.SimpleGraph.Clique
open Finset
namespace SimpleGraph
variable {V : Type*} [Fintype V] [DecidableEq V] (G H : SimpleGraph V) [DecidableRel G.Adj]
{n r : ℕ}
def IsTuranMaximal (r : ℕ) : Prop :=
G.CliqueFree (r + 1) ∧ ∀ (H : SimpleGraph V) [DecidableRel H.Adj],
H.CliqueFree (r +... | Mathlib/Combinatorics/SimpleGraph/Turan.lean | 54 | 62 | theorem turanGraph_eq_top : turanGraph n r = ⊤ ↔ r = 0 ∨ n ≤ r := by |
simp_rw [SimpleGraph.ext_iff, Function.funext_iff, turanGraph, top_adj, eq_iff_iff, not_iff_not]
refine ⟨fun h ↦ ?_, ?_⟩
· contrapose! h
use ⟨0, (Nat.pos_of_ne_zero h.1).trans h.2⟩, ⟨r, h.2⟩
simp [h.1.symm]
· rintro (rfl | h) a b
· simp [Fin.val_inj]
· rw [Nat.mod_eq_of_lt (a.2.trans_le h), Nat... | [
" G ≤ H ↔ G = H",
" DecidableRel (turanGraph n r).Adj",
" DecidableRel fun v w => ↑v % r ≠ ↑w % r",
" turanGraph n 0 = ⊤",
" (turanGraph n 0).Adj a b ↔ ⊤.Adj a b",
" turanGraph n r = ⊤ ↔ r = 0 ∨ n ≤ r",
" (∀ (a a_1 : Fin n), ↑a % r = ↑a_1 % r ↔ a = a_1) ↔ r = 0 ∨ n ≤ r",
" r = 0 ∨ n ≤ r",
" ∃ a a_1,... | [
" G ≤ H ↔ G = H",
" DecidableRel (turanGraph n r).Adj",
" DecidableRel fun v w => ↑v % r ≠ ↑w % r",
" turanGraph n 0 = ⊤",
" (turanGraph n 0).Adj a b ↔ ⊤.Adj a b"
] |
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Combinatorics.SimpleGraph.Basic
import Mathlib.Data.Rat.Cast.Order
import Mathlib.Order.Partition.Finpartition
import Mathlib.Tactic.GCongr
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Positivity
import Mathlib.Tactic.Ring
#align_import combinatorics.simp... | Mathlib/Combinatorics/SimpleGraph/Density.lean | 272 | 274 | theorem swap_mem_interedges_iff {x : α × α} : x.swap ∈ interedges r s t ↔ x ∈ interedges r t s := by |
rw [mem_interedges_iff, mem_interedges_iff, hr.iff]
exact and_left_comm
| [
" x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2",
" interedges r ∅ t = ∅",
" x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁",
" x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2",
" (interedges r s t).card + (interedges (fun x y => ¬r x y) s t).card = s.card * t.card",
" Disjoint (... | [
" x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2",
" interedges r ∅ t = ∅",
" x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁",
" x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2",
" (interedges r s t).card + (interedges (fun x y => ¬r x y) s t).card = s.card * t.card",
" Disjoint (... |
import Mathlib.Analysis.InnerProductSpace.Adjoint
import Mathlib.Analysis.Matrix
import Mathlib.Analysis.RCLike.Basic
import Mathlib.LinearAlgebra.UnitaryGroup
import Mathlib.Topology.UniformSpace.Matrix
#align_import analysis.normed_space.star.matrix from "leanprover-community/mathlib"@"468b141b14016d54b479eb7a0fff1... | Mathlib/Analysis/NormedSpace/Star/Matrix.lean | 49 | 77 | theorem entry_norm_bound_of_unitary {U : Matrix n n 𝕜} (hU : U ∈ Matrix.unitaryGroup n 𝕜)
(i j : n) : ‖U i j‖ ≤ 1 := by |
-- The norm squared of an entry is at most the L2 norm of its row.
have norm_sum : ‖U i j‖ ^ 2 ≤ ∑ x, ‖U i x‖ ^ 2 := by
apply Multiset.single_le_sum
· intro x h_x
rw [Multiset.mem_map] at h_x
cases' h_x with a h_a
rw [← h_a.2]
apply sq_nonneg
· rw [Multiset.mem_map]
use j
... | [
" ‖U i j‖ ≤ 1",
" ‖U i j‖ ^ 2 ≤ ∑ x : n, ‖U i x‖ ^ 2",
" ∀ x ∈ Multiset.map (fun x => ‖U i x‖ ^ 2) Finset.univ.val, 0 ≤ x",
" 0 ≤ x",
" 0 ≤ ‖U i a‖ ^ 2",
" ‖U i j‖ ^ 2 ∈ Multiset.map (fun x => ‖U i x‖ ^ 2) Finset.univ.val",
" ∃ a ∈ Finset.univ.val, ‖U i a‖ ^ 2 = ‖U i j‖ ^ 2",
" j ∈ Finset.univ.val ∧ ‖... | [] |
import Mathlib.NumberTheory.Padics.PadicIntegers
import Mathlib.RingTheory.ZMod
#align_import number_theory.padics.ring_homs from "leanprover-community/mathlib"@"565eb991e264d0db702722b4bde52ee5173c9950"
noncomputable section
open scoped Classical
open Nat LocalRing Padic
namespace PadicInt
variable {p : ℕ} [h... | Mathlib/NumberTheory/Padics/RingHoms.lean | 142 | 150 | theorem zmod_congr_of_sub_mem_span_aux (n : ℕ) (x : ℤ_[p]) (a b : ℤ)
(ha : x - a ∈ (Ideal.span {(p : ℤ_[p]) ^ n}))
(hb : x - b ∈ (Ideal.span {(p : ℤ_[p]) ^ n})) : (a : ZMod (p ^ n)) = b := by |
rw [Ideal.mem_span_singleton] at ha hb
rw [← sub_eq_zero, ← Int.cast_sub, ZMod.intCast_zmod_eq_zero_iff_dvd, Int.natCast_pow]
rw [← dvd_neg, neg_sub] at ha
have := dvd_add ha hb
rwa [sub_eq_add_neg, sub_eq_add_neg, add_assoc, neg_add_cancel_left, ← sub_eq_add_neg, ←
Int.cast_sub, pow_p_dvd_int_iff] at th... | [
" modPart p r < ↑p",
" ↑p = |↑p|",
" ↑p ≠ 0",
" IsUnit ↑r.den",
" ‖↑r.den‖ = 1",
" 1 ≤ ‖↑↑r.den‖",
" ¬‖↑r.den‖ < 1",
" False",
" ‖↑r * ↑r.den‖ = ‖↑r.num‖",
" ↑r * ↑r.den = ↑r.num",
" ‖↑r.num‖ < 1",
" ↑p ∣ r.num ∧ ↑p ∣ ↑r.den",
" ‖↑↑r.num‖ < 1 ∧ ‖↑↑↑r.den‖ < 1",
" p ∣ 1",
" ↑p ∣ r.num - r... | [
" modPart p r < ↑p",
" ↑p = |↑p|",
" ↑p ≠ 0",
" IsUnit ↑r.den",
" ‖↑r.den‖ = 1",
" 1 ≤ ‖↑↑r.den‖",
" ¬‖↑r.den‖ < 1",
" False",
" ‖↑r * ↑r.den‖ = ‖↑r.num‖",
" ↑r * ↑r.den = ↑r.num",
" ‖↑r.num‖ < 1",
" ↑p ∣ r.num ∧ ↑p ∣ ↑r.den",
" ‖↑↑r.num‖ < 1 ∧ ‖↑↑↑r.den‖ < 1",
" p ∣ 1",
" ↑p ∣ r.num - r... |
import Mathlib.Algebra.Order.Module.OrderedSMul
import Mathlib.Algebra.Order.Module.Pointwise
import Mathlib.Data.Real.Archimedean
#align_import data.real.pointwise from "leanprover-community/mathlib"@"dde670c9a3f503647fd5bfdf1037bad526d3397a"
open Set
open Pointwise
variable {ι : Sort*} {α : Type*} [LinearOrde... | Mathlib/Data/Real/Pointwise.lean | 37 | 46 | theorem Real.sInf_smul_of_nonneg (ha : 0 ≤ a) (s : Set ℝ) : sInf (a • s) = a • sInf s := by |
obtain rfl | hs := s.eq_empty_or_nonempty
· rw [smul_set_empty, Real.sInf_empty, smul_zero]
obtain rfl | ha' := ha.eq_or_lt
· rw [zero_smul_set hs, zero_smul]
exact csInf_singleton 0
by_cases h : BddBelow s
· exact ((OrderIso.smulRight ha').map_csInf' hs h).symm
· rw [Real.sInf_of_not_bddBelow (mt (b... | [
" sInf (a • s) = a • sInf s",
" sInf (a • ∅) = a • sInf ∅",
" sInf (0 • s) = 0 • sInf s",
" sInf 0 = 0"
] | [] |
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 | 111 | 111 | theorem log_neg_eq_log (x : ℝ) : log (-x) = log x := by | rw [← log_abs x, ← log_abs (-x), abs_neg]
| [
" 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 ≤ rexp x.log",
" 0 ≤ 1",
" x ≤ |x|",
" rexp (log 1) = rexp 0",
" |x|.log = x.log",
" (-x).log = x.log"
] | [
" 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 ≤ rexp x.log",
" 0 ≤ 1",
" x ≤ |x|",
" rexp (log 1) = rexp 0",
" |x|.log = x.log"
] |
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 | 72 | 73 | theorem projIcc_of_le_left (hx : x ≤ a) : projIcc a b h x = ⟨a, left_mem_Icc.2 h⟩ := by |
simp [projIcc, hx, hx.trans h]
| [
" projIcc a b h x = ⟨a, ⋯⟩"
] | [] |
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.RingTheory.Ideal.QuotientOperations
#align_import ring_theory.quotient_nilpotent from "leanprover-community/mathlib"@"da420a8c6dd5bdfb85c4ced85c34388f633bc6ff"
theorem Ideal.isRadical_iff_quotient_reduced {R : Type*} [CommRing R] (I : Ideal R) :
I.IsRad... | Mathlib/RingTheory/QuotientNilpotent.lean | 54 | 78 | theorem IsNilpotent.isUnit_quotient_mk_iff {R : Type*} [CommRing R] {I : Ideal R}
(hI : IsNilpotent I) {x : R} : IsUnit (Ideal.Quotient.mk I x) ↔ IsUnit x := by |
refine ⟨?_, fun h => h.map <| Ideal.Quotient.mk I⟩
revert x
apply Ideal.IsNilpotent.induction_on (R := R) (S := R) I hI <;> clear hI I
swap
· introv e h₁ h₂ h₃
apply h₁
apply h₂
exact
h₃.map
((DoubleQuot.quotQuotEquivQuotSup I J).trans
(Ideal.quotEquivOfEq (sup_eq_righ... | [
" I.IsRadical ↔ IsReduced (R ⧸ I)",
"R : Type u_1 inst✝ : CommRing R I : Ideal R | I.IsRadical",
" (RingHom.ker (Quotient.mk I)).IsRadical ↔ IsReduced (R ⧸ I)",
" P I",
" P ⊥",
" ⊥ ^ 2 = ⊥",
" P (I ^ 2)",
" (I ^ 2) ^ n.succ = ⊥",
" I ^ (2 * (n + 1)) ≤ I ^ (n + 1 + 1)",
" n + 1 + 1 ≤ 2 * (n + 1)",
... | [
" I.IsRadical ↔ IsReduced (R ⧸ I)",
"R : Type u_1 inst✝ : CommRing R I : Ideal R | I.IsRadical",
" (RingHom.ker (Quotient.mk I)).IsRadical ↔ IsReduced (R ⧸ I)",
" P I",
" P ⊥",
" ⊥ ^ 2 = ⊥",
" P (I ^ 2)",
" (I ^ 2) ^ n.succ = ⊥",
" I ^ (2 * (n + 1)) ≤ I ^ (n + 1 + 1)",
" n + 1 + 1 ≤ 2 * (n + 1)",
... |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.LinearAlgebra.FreeModule.PID
import Mathlib.LinearAlgebra.Matrix.AbsoluteValue
import Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue
import Mathlib.RingTheory.ClassGroup
import Mathlib.RingTheory.DedekindDomain.IntegralClosure
import Mathlib.Ri... | Mathlib/NumberTheory/ClassNumber/Finite.lean | 58 | 71 | theorem normBound_pos : 0 < normBound abv bS := by |
obtain ⟨i, j, k, hijk⟩ : ∃ i j k, Algebra.leftMulMatrix bS (bS i) j k ≠ 0 := by
by_contra! h
obtain ⟨i⟩ := bS.index_nonempty
apply bS.ne_zero i
apply
(injective_iff_map_eq_zero (Algebra.leftMulMatrix bS)).mp (Algebra.leftMulMatrix_injective bS)
ext j k
simp [h, DMatrix.zero_apply]
sim... | [
" 0 < normBound abv bS",
" ∃ i j k, (Algebra.leftMulMatrix bS) (bS i) j k ≠ 0",
" False",
" bS i = 0",
" (Algebra.leftMulMatrix bS) (bS i) = 0",
" (Algebra.leftMulMatrix bS) (bS i) j k = 0 j k",
" 0 <\n ↑(Fintype.card ι).factorial *\n (↑(Fintype.card ι) *\n (Finset.image (fun ijk => abv... | [] |
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Num.Lemmas
import Mathlib.Data.Option.Basic
import Mathlib.SetTheory.Cardinal.Basic
#align_import computability.encoding from "leanprover-community/mathlib"@"b6395b3a5acd655b16385fa0cdbf1961d6c34b3e"
universe u v
open Cardinal
namespace Computability
struc... | Mathlib/Computability/Encoding.lean | 134 | 140 | theorem decode_encodePosNum : ∀ n, decodePosNum (encodePosNum n) = n := by |
intro n
induction' n with m hm m hm <;> unfold encodePosNum decodePosNum
· rfl
· rw [hm]
exact if_neg (encodePosNum_nonempty m)
· exact congr_arg PosNum.bit0 hm
| [
" Function.Injective e.encode",
" some x✝¹ = some x✝",
" {blank, bit true, bit false, bra, ket, comma}.Nodup",
" ∀ (x : Γ'), x ∈ { val := {blank, bit true, bit false, bra, ket, comma}, nodup := ⋯ }",
" x✝ ∈ { val := {blank, bit true, bit false, bra, ket, comma}, nodup := ⋯ }",
" blank ∈ { val := {blank, b... | [
" Function.Injective e.encode",
" some x✝¹ = some x✝",
" {blank, bit true, bit false, bra, ket, comma}.Nodup",
" ∀ (x : Γ'), x ∈ { val := {blank, bit true, bit false, bra, ket, comma}, nodup := ⋯ }",
" x✝ ∈ { val := {blank, bit true, bit false, bra, ket, comma}, nodup := ⋯ }",
" blank ∈ { val := {blank, b... |
import Mathlib.Init.Data.Sigma.Lex
import Mathlib.Data.Prod.Lex
import Mathlib.Data.Sigma.Lex
import Mathlib.Order.Antichain
import Mathlib.Order.OrderIsoNat
import Mathlib.Order.WellFounded
import Mathlib.Tactic.TFAE
#align_import order.well_founded_set from "leanprover-community/mathlib"@"2c84c2c5496117349007d97104... | Mathlib/Order/WellFoundedSet.lean | 303 | 309 | theorem PartiallyWellOrderedOn.image_of_monotone_on (hs : s.PartiallyWellOrderedOn r)
(hf : ∀ a₁ ∈ s, ∀ a₂ ∈ s, r a₁ a₂ → r' (f a₁) (f a₂)) : (f '' s).PartiallyWellOrderedOn r' := by |
intro g' hg'
choose g hgs heq using hg'
obtain rfl : f ∘ g = g' := funext heq
obtain ⟨m, n, hlt, hmn⟩ := hs g hgs
exact ⟨m, n, hlt, hf _ (hgs m) _ (hgs n) hmn⟩
| [
" (s ∪ t).PartiallyWellOrderedOn r",
" ∃ m n, m < n ∧ r (f m) (f n)",
" (f '' s).PartiallyWellOrderedOn r'",
" ∃ m n, m < n ∧ r' (g' m) (g' n)",
" ∃ m n, m < n ∧ r' ((f ∘ g) m) ((f ∘ g) n)"
] | [
" (s ∪ t).PartiallyWellOrderedOn r",
" ∃ m n, m < n ∧ r (f m) (f n)"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.