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.Data.Finsupp.Multiset
import Mathlib.Data.Nat.GCD.BigOperators
import Mathlib.Data.Nat.PrimeFin
import Mathlib.NumberTheory.Padics.PadicVal
import Mathlib.Order.Interval.Finset.Nat
#align_import data.nat.factorization.basic from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
... | Mathlib/Data/Nat/Factorization/Basic.lean | 120 | 120 | theorem factorization_one : factorization 1 = 0 := by | ext; simp [factorization]
| [
" ∀ (a : ℕ), a ∈ n.primeFactors ↔ (fun p => if p.Prime then padicValNat p n else 0) a ≠ 0",
" ∀ (a : ℕ), a.Prime → (a ∣ n ∧ ¬n = 0 ↔ ¬a = 1 ∧ ¬n = 0 ∧ a ∣ n)",
" n.factorization p = padicValNat p n",
" count p n.factors = n.factorization p",
" count p (factors 0) = (factorization 0) p",
" 0 = n.factorizat... | [
" ∀ (a : ℕ), a ∈ n.primeFactors ↔ (fun p => if p.Prime then padicValNat p n else 0) a ≠ 0",
" ∀ (a : ℕ), a.Prime → (a ∣ n ∧ ¬n = 0 ↔ ¬a = 1 ∧ ¬n = 0 ∧ a ∣ n)",
" n.factorization p = padicValNat p n",
" count p n.factors = n.factorization p",
" count p (factors 0) = (factorization 0) p",
" 0 = n.factorizat... |
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.Algebra.Polynomial.Monic
import Mathlib.Algebra.Polynomial.RingDivision
import Mathlib.Tactic.Abel
#align_import ring_theory.polynomial.pochhammer from "leanprover-community/mathlib"@"53b216bcc1146df1c4a0a868778... | Mathlib/RingTheory/Polynomial/Pochhammer.lean | 143 | 152 | theorem ascPochhammer_succ_comp_X_add_one (n : ℕ) :
(ascPochhammer S (n + 1)).comp (X + 1) =
ascPochhammer S (n + 1) + (n + 1) • (ascPochhammer S n).comp (X + 1) := by |
suffices (ascPochhammer ℕ (n + 1)).comp (X + 1) =
ascPochhammer ℕ (n + 1) + (n + 1) * (ascPochhammer ℕ n).comp (X + 1)
by simpa [map_comp] using congr_arg (Polynomial.map (Nat.castRingHom S)) this
nth_rw 2 [ascPochhammer_succ_left]
rw [← add_mul, ascPochhammer_succ_right ℕ n, mul_comp, mul_comm, add_co... | [
" ascPochhammer S 1 = X",
" ascPochhammer S (n + 1) = X * (ascPochhammer S n).comp (X + 1)",
" (ascPochhammer S n).Monic",
" (ascPochhammer S 0).Monic",
" (ascPochhammer S (n + 1)).Monic",
" map f (ascPochhammer S n) = ascPochhammer T n",
" map f (ascPochhammer S 0) = ascPochhammer T 0",
" map f (ascP... | [
" ascPochhammer S 1 = X",
" ascPochhammer S (n + 1) = X * (ascPochhammer S n).comp (X + 1)",
" (ascPochhammer S n).Monic",
" (ascPochhammer S 0).Monic",
" (ascPochhammer S (n + 1)).Monic",
" map f (ascPochhammer S n) = ascPochhammer T n",
" map f (ascPochhammer S 0) = ascPochhammer T 0",
" map f (ascP... |
import Mathlib.Algebra.BigOperators.Finsupp
import Mathlib.Algebra.BigOperators.Finprod
import Mathlib.Data.Fintype.BigOperators
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.LinearIndependent
import Mathlib.SetTheory.Cardinal.Cofinality
#align_import linear_algebra.basis from "leanprover-communit... | Mathlib/LinearAlgebra/Basis.lean | 186 | 189 | theorem repr_support_subset_of_mem_span (s : Set ι) {m : M}
(hm : m ∈ span R (b '' s)) : ↑(b.repr m).support ⊆ s := by |
rcases (Finsupp.mem_span_image_iff_total _).1 hm with ⟨l, hl, rfl⟩
rwa [repr_total, ← Finsupp.mem_supported R l]
| [
" { repr := b } = default",
" f = g",
" { repr := repr✝ } = g",
" { repr := repr✝¹ } = { repr := repr✝ }",
" ↑f.repr.symm = ↑g.repr.symm",
" (↑f.repr.symm ∘ₗ Finsupp.lsingle a✝) 1 = (↑g.repr.symm ∘ₗ Finsupp.lsingle a✝) 1",
" b.repr.symm (Finsupp.single i c) = b.repr.symm (c • Finsupp.single i 1)",
" b... | [
" { repr := b } = default",
" f = g",
" { repr := repr✝ } = g",
" { repr := repr✝¹ } = { repr := repr✝ }",
" ↑f.repr.symm = ↑g.repr.symm",
" (↑f.repr.symm ∘ₗ Finsupp.lsingle a✝) 1 = (↑g.repr.symm ∘ₗ Finsupp.lsingle a✝) 1",
" b.repr.symm (Finsupp.single i c) = b.repr.symm (c • Finsupp.single i 1)",
" b... |
import Mathlib.Data.Countable.Basic
import Mathlib.Data.Fin.VecNotation
import Mathlib.Order.Disjointed
import Mathlib.MeasureTheory.OuterMeasure.Defs
#align_import measure_theory.measure.outer_measure from "leanprover-community/mathlib"@"343e80208d29d2d15f8050b929aa50fe4ce71b55"
noncomputable section
open Set F... | Mathlib/MeasureTheory/OuterMeasure/Basic.lean | 125 | 126 | theorem measure_union_null_iff : μ (s ∪ t) = 0 ↔ μ s = 0 ∧ μ t = 0 := by |
simp [union_eq_iUnion, and_comm]
| [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... | [
" μ (⋃ i, s i) ≤ ∑' (i : ι), μ (s i)",
" (fun x x_1 => x ≤ x_1) (μ (⨆ i, t i)) (∑' (i : ℕ), μ (t i))",
" μ (⋃ i, t i) = μ (⋃ i, disjointed t i)",
" ∑' (i : ℕ), μ (disjointed t i) ≤ ∑' (i : ℕ), μ (t i)",
" disjointed t a✝ ⊆ t a✝",
" μ (⋃ i ∈ I, s i) ≤ ∑' (i : ↑I), μ (s ↑i)",
" μ (⋃ x, s ↑x) ≤ ∑' (i : ↑I)... |
import Mathlib.Analysis.Convex.Normed
import Mathlib.Analysis.Convex.Strict
import Mathlib.Analysis.Normed.Order.Basic
import Mathlib.Analysis.NormedSpace.AddTorsor
import Mathlib.Analysis.NormedSpace.Pointwise
import Mathlib.Analysis.NormedSpace.Ray
#align_import analysis.convex.strict_convex_space from "leanprover-... | Mathlib/Analysis/Convex/StrictConvexSpace.lean | 123 | 130 | theorem StrictConvexSpace.of_norm_add_ne_two
(h : ∀ ⦃x y : E⦄, ‖x‖ = 1 → ‖y‖ = 1 → x ≠ y → ‖x + y‖ ≠ 2) : StrictConvexSpace ℝ E := by |
refine
StrictConvexSpace.of_norm_combo_ne_one fun x y hx hy hne =>
⟨1 / 2, 1 / 2, one_half_pos.le, one_half_pos.le, add_halves _, ?_⟩
rw [← smul_add, norm_smul, Real.norm_of_nonneg one_half_pos.le, one_div, ← div_eq_inv_mul, Ne,
div_eq_one_iff_eq (two_ne_zero' ℝ)]
exact h hx hy hne
| [
" StrictConvex 𝕜 (closedBall x r)",
" StrictConvex 𝕜 (x +ᵥ closedBall 0 r)",
" StrictConvex 𝕜 (closedBall 0 r)",
" StrictConvexSpace ℝ E",
" (fun x y => ∃ c, (AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)) x y",
" ∃ c, (AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)",
" (AffineMap.lineMa... | [
" StrictConvex 𝕜 (closedBall x r)",
" StrictConvex 𝕜 (x +ᵥ closedBall 0 r)",
" StrictConvex 𝕜 (closedBall 0 r)",
" StrictConvexSpace ℝ E",
" (fun x y => ∃ c, (AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)) x y",
" ∃ c, (AffineMap.lineMap x y) c ∈ interior (closedBall 0 1)",
" (AffineMap.lineMa... |
import Mathlib.Data.Matrix.Basic
import Mathlib.LinearAlgebra.Matrix.Trace
#align_import data.matrix.basis from "leanprover-community/mathlib"@"320df450e9abeb5fc6417971e75acb6ae8bc3794"
variable {l m n : Type*}
variable {R α : Type*}
namespace Matrix
open Matrix
variable [DecidableEq l] [DecidableEq m] [Decida... | Mathlib/Data/Matrix/Basis.lean | 139 | 140 | theorem apply_of_row_ne {i i' : m} (hi : i ≠ i') (j j' : n) (a : α) :
stdBasisMatrix i j a i' j' = 0 := by | simp [hi]
| [
" r • stdBasisMatrix i j a = stdBasisMatrix i j (r • a)",
" (r • fun i' j' => if i = i' ∧ j = j' then a else 0) = fun i' j' => if i = i' ∧ j = j' then r • a else 0",
" (r • fun i' j' => if i = i' ∧ j = j' then a else 0) i✝ j✝ = if i = i✝ ∧ j = j✝ then r • a else 0",
" stdBasisMatrix i j 0 = 0",
" (fun i' j'... | [
" r • stdBasisMatrix i j a = stdBasisMatrix i j (r • a)",
" (r • fun i' j' => if i = i' ∧ j = j' then a else 0) = fun i' j' => if i = i' ∧ j = j' then r • a else 0",
" (r • fun i' j' => if i = i' ∧ j = j' then a else 0) i✝ j✝ = if i = i✝ ∧ j = j✝ then r • a else 0",
" stdBasisMatrix i j 0 = 0",
" (fun i' j'... |
import Mathlib.Algebra.Algebra.Defs
import Mathlib.Algebra.Polynomial.FieldDivision
import Mathlib.FieldTheory.Minpoly.Basic
import Mathlib.RingTheory.Adjoin.Basic
import Mathlib.RingTheory.FinitePresentation
import Mathlib.RingTheory.FiniteType
import Mathlib.RingTheory.PowerBasis
import Mathlib.RingTheory.PrincipalI... | Mathlib/RingTheory/AdjoinRoot.lean | 120 | 121 | theorem smul_of [DistribSMul S R] [IsScalarTower S R R] (a : S) (x : R) :
a • of f x = of f (a • x) := by | rw [of, RingHom.comp_apply, RingHom.comp_apply, smul_mk, smul_C]
| [
" span {f} ≠ ⊤",
" ∀ (x : R), IsUnit x → ¬C x = f",
" False",
" a • (of f) x = (of f) (a • x)"
] | [
" span {f} ≠ ⊤",
" ∀ (x : R), IsUnit x → ¬C x = f",
" False"
] |
import Batteries.Classes.Order
namespace Batteries.PairingHeapImp
inductive Heap (α : Type u) where
| nil : Heap α
| node (a : α) (child sibling : Heap α) : Heap α
deriving Repr
def Heap.size : Heap α → Nat
| .nil => 0
| .node _ c s => c.size + 1 + s.size
def Heap.singleton (a : α) : Heap α := .... | .lake/packages/batteries/Batteries/Data/PairingHeap.lean | 107 | 111 | theorem Heap.noSibling_tail? {s : Heap α} : s.tail? le = some s' →
s'.NoSibling := by |
simp only [Heap.tail?]; intro eq
match eq₂ : s.deleteMin le, eq with
| some (a, tl), rfl => exact noSibling_deleteMin eq₂
| [
" (merge le s₁ s₂).NoSibling",
" (match s₁, s₂ with\n | nil, nil => nil\n | nil, node a₂ c₂ sibling => node a₂ c₂ nil\n | node a₁ c₁ sibling, nil => node a₁ c₁ nil\n | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>\n if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) ni... | [
" (merge le s₁ s₂).NoSibling",
" (match s₁, s₂ with\n | nil, nil => nil\n | nil, node a₂ c₂ sibling => node a₂ c₂ nil\n | node a₁ c₁ sibling, nil => node a₁ c₁ nil\n | node a₁ c₁ sibling, node a₂ c₂ sibling_1 =>\n if le a₁ a₂ = true then node a₁ (node a₂ c₂ c₁) nil else node a₂ (node a₁ c₁ c₂) ni... |
import Mathlib.Data.Opposite
import Mathlib.Data.Set.Defs
#align_import data.set.opposite from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
variable {α : Type*}
open Opposite
namespace Set
protected def op (s : Set α) : Set αᵒᵖ :=
unop ⁻¹' s
#align set.op Set.op
protected def u... | Mathlib/Data/Set/Opposite.lean | 92 | 96 | theorem singleton_op_unop (x : α) : ({op x} : Set αᵒᵖ).unop = {x} := by |
ext
constructor
· apply op_injective
· apply unop_injective
| [
" { unop := a } ∈ s.op ↔ a ∈ s",
" a.unop ∈ s.unop ↔ a ∈ s",
" {x}.op = {{ unop := x }}",
" x✝ ∈ {x}.op ↔ x✝ ∈ {{ unop := x }}",
" x✝ ∈ {x}.op → x✝ ∈ {{ unop := x }}",
" x✝ ∈ {{ unop := x }} → x✝ ∈ {x}.op",
" {x}.unop = {x.unop}",
" x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}",
" x✝ ∈ {x}.unop → x✝ ∈ {x.unop}",
... | [
" { unop := a } ∈ s.op ↔ a ∈ s",
" a.unop ∈ s.unop ↔ a ∈ s",
" {x}.op = {{ unop := x }}",
" x✝ ∈ {x}.op ↔ x✝ ∈ {{ unop := x }}",
" x✝ ∈ {x}.op → x✝ ∈ {{ unop := x }}",
" x✝ ∈ {{ unop := x }} → x✝ ∈ {x}.op",
" {x}.unop = {x.unop}",
" x✝ ∈ {x}.unop ↔ x✝ ∈ {x.unop}",
" x✝ ∈ {x}.unop → x✝ ∈ {x.unop}",
... |
import Mathlib.Probability.ProbabilityMassFunction.Monad
#align_import probability.probability_mass_function.constructions from "leanprover-community/mathlib"@"4ac69b290818724c159de091daa3acd31da0ee6d"
universe u
namespace PMF
noncomputable section
variable {α β γ : Type*}
open scoped Classical
open NNReal ENN... | Mathlib/Probability/ProbabilityMassFunction/Constructions.lean | 70 | 70 | theorem map_comp (g : β → γ) : (p.map f).map g = p.map (g ∘ f) := by | simp [map, Function.comp]
| [
" (map f p) b = ∑' (a : α), if b = f a then p a else 0",
" b ∈ (map f p).support ↔ b ∈ f '' p.support",
" b ∈ (map f p).support ↔ ∃ a ∈ p.support, f a = b",
" map g (map f p) = map (g ∘ f) p"
] | [
" (map f p) b = ∑' (a : α), if b = f a then p a else 0",
" b ∈ (map f p).support ↔ b ∈ f '' p.support",
" b ∈ (map f p).support ↔ ∃ a ∈ p.support, f a = b"
] |
import Mathlib.Geometry.Manifold.MFDeriv.FDeriv
noncomputable section
open scoped Manifold
open Bundle Set Topology
section SpecificFunctions
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜] {E : Type*} [NormedAddCommGroup E]
[NormedSpace 𝕜 E] {H : Type*} [TopologicalSpace H] (I : ModelWithCorners 𝕜 E H)... | Mathlib/Geometry/Manifold/MFDeriv/SpecificFunctions.lean | 291 | 297 | theorem tangentMapWithin_prod_fst {s : Set (M × M')} {p : TangentBundle (I.prod I') (M × M')}
(hs : UniqueMDiffWithinAt (I.prod I') s p.proj) :
tangentMapWithin (I.prod I') I Prod.fst s p = ⟨p.proj.1, p.2.1⟩ := by |
simp only [tangentMapWithin]
rw [mfderivWithin_fst]
· rcases p with ⟨⟩; rfl
· exact hs
| [
" HasMFDerivAt (I.prod I') I Prod.fst x (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))",
" HasFDerivWithinAt (writtenInExtChartAt (I.prod I') I x Prod.fst)\n (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) (range ↑(I.prod I'))\n (↑(extChartAt (I.prod I') x) x... | [
" HasMFDerivAt (I.prod I') I Prod.fst x (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2))",
" HasFDerivWithinAt (writtenInExtChartAt (I.prod I') I x Prod.fst)\n (ContinuousLinearMap.fst 𝕜 (TangentSpace I x.1) (TangentSpace I' x.2)) (range ↑(I.prod I'))\n (↑(extChartAt (I.prod I') x) x... |
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 | 193 | 201 | theorem Biprod.isIso_inl_iff_isZero (X Y : C) : IsIso (biprod.inl : X ⟶ X ⊞ Y) ↔ IsZero Y := by |
rw [biprod.isIso_inl_iff_id_eq_fst_comp_inl, ← biprod.total, add_right_eq_self]
constructor
· intro h
replace h := h =≫ biprod.snd
simpa [← IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] using h
· intro h
rw [IsZero.iff_isSplitEpi_eq_zero (biprod.snd : X ⊞ Y ⟶ Y)] at h
rw [h, zero_comp... | [
" 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",
" Epi f",
" Epi (factorThruImage f ≫ image.ι f)",
" IsIso (𝟙 X)",
" ¬IsZero X",
" 0 ≫ 0 = 𝟙 0 ∧ 0 ≫ 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)",
" kernel.ι f = 0",
" Epi f",
" Epi (factorThruImage f ≫ image.ι f)",
" IsIso (𝟙 X)",
" ¬IsZero X",
" 0 ≫ 0 = 𝟙 0 ∧ 0 ≫ 0 =... |
import Mathlib.Algebra.Order.Ring.Abs
import Mathlib.Data.ZMod.Basic
#align_import data.zmod.parity from "leanprover-community/mathlib"@"048240e809f04e2bde02482ab44bc230744cc6c9"
namespace ZMod
theorem eq_zero_iff_even {n : ℕ} : (n : ZMod 2) = 0 ↔ Even n :=
(CharP.cast_eq_zero_iff (ZMod 2) 2 n).trans even_iff_... | Mathlib/Data/ZMod/Parity.lean | 28 | 29 | theorem eq_one_iff_odd {n : ℕ} : (n : ZMod 2) = 1 ↔ Odd n := by |
rw [← @Nat.cast_one (ZMod 2), ZMod.eq_iff_modEq_nat, Nat.odd_iff, Nat.ModEq]
| [
" ↑n = 1 ↔ Odd n"
] | [] |
import Mathlib.Analysis.Calculus.Deriv.Add
import Mathlib.Analysis.Calculus.Deriv.Linear
import Mathlib.LinearAlgebra.AffineSpace.AffineMap
variable {𝕜 : Type*} [NontriviallyNormedField 𝕜]
{E : Type*} [NormedAddCommGroup E] [NormedSpace 𝕜 E]
(f : 𝕜 →ᵃ[𝕜] E) {a b : E} {L : Filter 𝕜} {s : Set 𝕜} {x : 𝕜}
n... | Mathlib/Analysis/Calculus/Deriv/AffineMap.lean | 32 | 34 | theorem hasStrictDerivAt : HasStrictDerivAt f (f.linear 1) x := by |
rw [f.decomp]
exact f.linear.hasStrictDerivAt.add_const (f 0)
| [
" HasStrictDerivAt (⇑f) (f.linear 1) x",
" HasStrictDerivAt (⇑f.linear + fun x => f 0) (f.linear 1) x"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Pow.Real
import Mathlib.Data.Int.Log
#align_import analysis.special_functions.log.base from "leanprover-community/mathlib"@"f23a09ce6d3f367220dc3cecad6b7eb69eb01690"
open Set Filter Function
open Topology
noncomputable section
namespace Real
variable {b x y : ℝ}
-- @... | Mathlib/Analysis/SpecialFunctions/Log/Base.lean | 53 | 53 | theorem logb_one : logb b 1 = 0 := by | simp [logb]
| [
" b.logb 0 = 0",
" b.logb 1 = 0"
] | [
" b.logb 0 = 0"
] |
import Mathlib.Data.Fintype.Basic
import Mathlib.ModelTheory.Substructures
#align_import model_theory.elementary_maps from "leanprover-community/mathlib"@"d11893b411025250c8e61ff2f12ccbd7ee35ab15"
open FirstOrder
namespace FirstOrder
namespace Language
open Structure
variable (L : Language) (M : Type*) (N : T... | Mathlib/ModelTheory/ElementaryMaps.lean | 103 | 104 | theorem map_sentence (f : M ↪ₑ[L] N) (φ : L.Sentence) : M ⊨ φ ↔ N ⊨ φ := by |
rw [Sentence.Realize, Sentence.Realize, ← f.map_formula, Unique.eq_default (f ∘ default)]
| [
" f = g",
" { toFun := toFun✝, map_formula' := map_formula'✝ } = g",
" { toFun := toFun✝¹, map_formula' := map_formula'✝¹ } = { toFun := toFun✝, map_formula' := map_formula'✝ }",
" toFun✝¹ = toFun✝",
" toFun✝¹ x = toFun✝ x",
" φ.Realize (⇑f ∘ v) (⇑f ∘ xs) ↔ φ.Realize v xs",
" (φ.restrictFreeVar id).Real... | [
" f = g",
" { toFun := toFun✝, map_formula' := map_formula'✝ } = g",
" { toFun := toFun✝¹, map_formula' := map_formula'✝¹ } = { toFun := toFun✝, map_formula' := map_formula'✝ }",
" toFun✝¹ = toFun✝",
" toFun✝¹ x = toFun✝ x",
" φ.Realize (⇑f ∘ v) (⇑f ∘ xs) ↔ φ.Realize v xs",
" (φ.restrictFreeVar id).Real... |
import Mathlib.Data.Fin.VecNotation
import Mathlib.Logic.Embedding.Set
#align_import logic.equiv.fin from "leanprover-community/mathlib"@"bd835ef554f37ef9b804f0903089211f89cb370b"
assert_not_exists MonoidWithZero
universe u
variable {m n : ℕ}
def finZeroEquiv : Fin 0 ≃ Empty :=
Equiv.equivEmpty _
#align fin_... | Mathlib/Logic/Equiv/Fin.lean | 111 | 112 | theorem finSuccEquiv'_at (i : Fin (n + 1)) : (finSuccEquiv' i) i = none := by |
simp [finSuccEquiv']
| [
" (fun b => Bool.casesOn b 0 1) (![false, true] 0) = 0 ∧ (fun b => Bool.casesOn b 0 1) (![false, true] 1) = 1",
" ![false, true] ((fun b => Bool.casesOn b 0 1) false) = false ∧\n ![false, true] ((fun b => Bool.casesOn b 0 1) true) = true",
" (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.univ.pi (cons s (cons t finZ... | [
" (fun b => Bool.casesOn b 0 1) (![false, true] 0) = 0 ∧ (fun b => Bool.casesOn b 0 1) (![false, true] 1) = 1",
" ![false, true] ((fun b => Bool.casesOn b 0 1) false) = false ∧\n ![false, true] ((fun b => Bool.casesOn b 0 1) true) = true",
" (fun f => (f 0, f 1)) ⁻¹' s ×ˢ t = Set.univ.pi (cons s (cons t finZ... |
import Mathlib.Order.BoundedOrder
import Mathlib.Order.MinMax
import Mathlib.Algebra.NeZero
import Mathlib.Algebra.Order.Monoid.Defs
#align_import algebra.order.monoid.canonical.defs from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
universe u
variable {α : Type u}
class ExistsMulOf... | Mathlib/Algebra/Order/Monoid/Canonical/Defs.lean | 148 | 150 | theorem le_mul_self : a ≤ b * a := by |
rw [mul_comm]
exact le_self_mul
| [
" a ≤ b * a",
" a ≤ a * b"
] | [] |
import Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic
#align_import number_theory.legendre_symbol.basic from "leanprover-community/mathlib"@"5b2fe80501ff327b9109fb09b7cc8c325cd0d7d9"
open Nat
section Euler
section Legendre
open ZMod
variable (p : ℕ) [Fact p.Prime]
def legendreSym (a : ℤ) : ℤ :=
... | Mathlib/NumberTheory/LegendreSymbol/Basic.lean | 152 | 152 | theorem at_zero : legendreSym p 0 = 0 := by | rw [legendreSym, Int.cast_zero, MulChar.map_zero]
| [
" ↑(legendreSym p a) = ↑a ^ (p / 2)",
" ↑0 = 0",
" ↑(legendreSym 2 a) = ↑a ^ (2 / 2)",
" ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → 1 = ↑a ^ 1",
" ¬b = 0 → 1 = b ^ 1",
" ¬⟨0, ⋯⟩ = 0 → 1 = ⟨0, ⋯⟩ ^ 1",
" ¬⟨1, ⋯⟩ = 0 → 1 = ⟨1, ⋯⟩ ^ 1",
" p = Fintype.card (ZMod p)",
" legendreS... | [
" ↑(legendreSym p a) = ↑a ^ (p / 2)",
" ↑0 = 0",
" ↑(legendreSym 2 a) = ↑a ^ (2 / 2)",
" ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → ↑1 = ↑a ^ (2 / 2)",
" ¬↑a = 0 → 1 = ↑a ^ 1",
" ¬b = 0 → 1 = b ^ 1",
" ¬⟨0, ⋯⟩ = 0 → 1 = ⟨0, ⋯⟩ ^ 1",
" ¬⟨1, ⋯⟩ = 0 → 1 = ⟨1, ⋯⟩ ^ 1",
" p = Fintype.card (ZMod p)"
] |
import Mathlib.CategoryTheory.Action
import Mathlib.Combinatorics.Quiver.Arborescence
import Mathlib.Combinatorics.Quiver.ConnectedComponent
import Mathlib.GroupTheory.FreeGroup.IsFreeGroup
#align_import group_theory.nielsen_schreier from "leanprover-community/mathlib"@"1bda4fc53de6ade5ab9da36f2192e24e2084a2ce"
n... | Mathlib/GroupTheory/FreeGroup/NielsenSchreier.lean | 195 | 202 | theorem loopOfHom_eq_id {a b : Generators G} (e) (H : e ∈ wideSubquiverSymmetrify T a b) :
loopOfHom T (of e) = 𝟙 (root' T) := by |
rw [loopOfHom, ← Category.assoc, IsIso.comp_inv_eq, Category.id_comp]
cases' H with H H
· rw [treeHom_eq T (Path.cons default ⟨Sum.inl e, H⟩), homOfPath]
rfl
· rw [treeHom_eq T (Path.cons default ⟨Sum.inr e, H⟩), homOfPath]
simp only [IsIso.inv_hom_id, Category.comp_id, Category.assoc, treeHom]
| [
" ∀ {X : Type u} [inst : Group X] (f : Labelling (Generators (ActionCategory G A)) X),\n ∃! F, ∀ (a b : Generators (ActionCategory G A)) (g : a ⟶ b), F.map ((fun {a b} e => ⟨IsFreeGroup.of ↑e, ⋯⟩) g) = f g",
" ∃! F, ∀ (a b : Generators (ActionCategory G A)) (g : a ⟶ b), F.map ((fun {a b} e => ⟨IsFreeGroup.of ↑... | [
" ∀ {X : Type u} [inst : Group X] (f : Labelling (Generators (ActionCategory G A)) X),\n ∃! F, ∀ (a b : Generators (ActionCategory G A)) (g : a ⟶ b), F.map ((fun {a b} e => ⟨IsFreeGroup.of ↑e, ⋯⟩) g) = f g",
" ∃! F, ∀ (a b : Generators (ActionCategory G A)) (g : a ⟶ b), F.map ((fun {a b} e => ⟨IsFreeGroup.of ↑... |
import Mathlib.Analysis.Complex.Circle
import Mathlib.Analysis.SpecialFunctions.Complex.Log
#align_import analysis.special_functions.complex.circle from "leanprover-community/mathlib"@"f333194f5ecd1482191452c5ea60b37d4d6afa08"
open Complex Function Set
open Real
| Mathlib/Analysis/SpecialFunctions/Complex/Circle.lean | 37 | 38 | theorem arg_expMapCircle {x : ℝ} (h₁ : -π < x) (h₂ : x ≤ π) : arg (expMapCircle x) = x := by |
rw [expMapCircle_apply, exp_mul_I, arg_cos_add_sin_mul_I ⟨h₁, h₂⟩]
| [
" (↑(expMapCircle x)).arg = x"
] | [] |
import Mathlib.Control.Applicative
import Mathlib.Control.Traversable.Basic
import Mathlib.Data.List.Forall2
import Mathlib.Data.Set.Functor
#align_import control.traversable.instances from "leanprover-community/mathlib"@"18a5306c091183ac90884daa9373fa3b178e8607"
universe u v
section Option
open Functor
variab... | Mathlib/Control/Traversable/Instances.lean | 47 | 51 | theorem Option.naturality {α β} (f : α → F β) (x : Option α) :
η (Option.traverse f x) = Option.traverse (@η _ ∘ f) x := by |
-- Porting note: added `ApplicativeTransformation` theorems
cases' x with x <;> simp! [*, functor_norm, ApplicativeTransformation.preserves_map,
ApplicativeTransformation.preserves_seq, ApplicativeTransformation.preserves_pure]
| [
" Option.traverse pure x = x",
" Option.traverse pure none = none",
" Option.traverse pure (some val✝) = some val✝",
" Option.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Comp.mk (Option.traverse f <$> Option.traverse g x)",
" Option.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) none = Comp.mk (Option.trav... | [
" Option.traverse pure x = x",
" Option.traverse pure none = none",
" Option.traverse pure (some val✝) = some val✝",
" Option.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) x = Comp.mk (Option.traverse f <$> Option.traverse g x)",
" Option.traverse (Comp.mk ∘ (fun x => f <$> x) ∘ g) none = Comp.mk (Option.trav... |
import Mathlib.RingTheory.FiniteType
import Mathlib.RingTheory.Localization.AtPrime
import Mathlib.RingTheory.Localization.Away.Basic
import Mathlib.RingTheory.Localization.Integer
import Mathlib.RingTheory.Localization.Submodule
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.RingTheory.RingHomProperties
im... | Mathlib/RingTheory/LocalProperties.lean | 290 | 300 | theorem eq_zero_of_localization (r : R)
(h : ∀ (J : Ideal R) (hJ : J.IsMaximal), algebraMap R (Localization.AtPrime J) r = 0) :
r = 0 := by |
rw [← Ideal.span_singleton_eq_bot]
apply ideal_eq_bot_of_localization
intro J hJ
delta IsLocalization.coeSubmodule
erw [Submodule.map_span, Submodule.span_eq_bot]
rintro _ ⟨_, h', rfl⟩
cases Set.mem_singleton_iff.mpr h'
exact h J hJ
| [
" I ≤ J",
" x ∈ J",
" Submodule.colon J (span {x}) = ⊤",
" ¬∃ M, M.IsMaximal ∧ Submodule.colon J (span {x}) ≤ M",
" ∀ (M : Ideal R), M.IsMaximal → ¬Submodule.colon J (span {x}) ≤ M",
" False",
" s * m * x ∈ J",
" Ideal.map (algebraMap R (Localization.AtPrime P)) I = Ideal.map (algebraMap R (Localizati... | [
" I ≤ J",
" x ∈ J",
" Submodule.colon J (span {x}) = ⊤",
" ¬∃ M, M.IsMaximal ∧ Submodule.colon J (span {x}) ≤ M",
" ∀ (M : Ideal R), M.IsMaximal → ¬Submodule.colon J (span {x}) ≤ M",
" False",
" s * m * x ∈ J",
" Ideal.map (algebraMap R (Localization.AtPrime P)) I = Ideal.map (algebraMap R (Localizati... |
import Mathlib.Algebra.Module.Equiv
import Mathlib.Algebra.Module.Submodule.Basic
import Mathlib.Algebra.PUnitInstances
import Mathlib.Data.Set.Subsingleton
#align_import algebra.module.submodule.lattice from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
universe v
variable {R S M : Ty... | Mathlib/Algebra/Module/Submodule/Lattice.lean | 122 | 125 | theorem subsingleton_iff_eq_bot : Subsingleton p ↔ p = ⊥ := by |
rw [subsingleton_iff, Submodule.eq_bot_iff]
refine ⟨fun h x hx ↦ by simpa using h ⟨x, hx⟩ ⟨0, p.zero_mem⟩,
fun h ⟨x, hx⟩ ⟨y, hy⟩ ↦ by simp [h x hx, h y hy]⟩
| [
" ∀ (c : R) {x : M},\n x ∈ { carrier := {0}, add_mem' := ⋯, zero_mem' := ⋯ }.carrier →\n c • x ∈ { carrier := {0}, add_mem' := ⋯, zero_mem' := ⋯ }.carrier",
" x ∈ ⊥ → x ∈ p",
" x = y",
" ⟨x, xm⟩ = y",
" ⟨x, xm⟩ = ⟨y, ym⟩",
" 0 = y",
" p ≠ ⊥ ↔ ∃ x ∈ p, x ≠ 0",
" Subsingleton ↥p ↔ p = ⊥",
" (∀... | [
" ∀ (c : R) {x : M},\n x ∈ { carrier := {0}, add_mem' := ⋯, zero_mem' := ⋯ }.carrier →\n c • x ∈ { carrier := {0}, add_mem' := ⋯, zero_mem' := ⋯ }.carrier",
" x ∈ ⊥ → x ∈ p",
" x = y",
" ⟨x, xm⟩ = y",
" ⟨x, xm⟩ = ⟨y, ym⟩",
" 0 = y",
" p ≠ ⊥ ↔ ∃ x ∈ p, x ≠ 0"
] |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Binary
variable (xs : Vector α n) (ys : Vector β n)
@[simp]
theorem mapAccumr₂_mapAccumr_left (f₁ : γ → β → σ₁ → σ₁ × ζ) (f₂ : α → σ₂ → σ₂ × γ) :
(mapAccumr₂ f₁ (mapAccumr f₂... | Mathlib/Data/Vector/MapLemmas.lean | 92 | 100 | theorem mapAccumr_mapAccumr₂ (f₁ : γ → σ₁ → σ₁ × ζ) (f₂ : α → β → σ₂ → σ₂ × γ) :
(mapAccumr f₁ (mapAccumr₂ f₂ xs ys s₂).snd s₁)
= let m := mapAccumr₂ (fun x y s =>
let r₂ := f₂ x y s.snd
let r₁ := f₁ r₂.snd s.fst
((r₁.fst, r₂.fst), r₁.snd)
) xs ys (s₁, s₂)
(m.fst.fst,... |
induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
| [
" mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).2 ys s₁ =\n let m :=\n mapAccumr₂\n (fun x y s =>\n let r₂ := f₂ x s.2;\n let r₁ := f₁ r₂.2 y s.1;\n ((r₁.1, r₂.1), r₁.2))\n xs ys (s₁, s₂);\n (m.1.1, m.2)",
" mapAccumr₂ f₁ (mapAccumr f₂ nil s₂).2 nil s₁ =\n let m :=\n ... | [
" mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).2 ys s₁ =\n let m :=\n mapAccumr₂\n (fun x y s =>\n let r₂ := f₂ x s.2;\n let r₁ := f₁ r₂.2 y s.1;\n ((r₁.1, r₂.1), r₁.2))\n xs ys (s₁, s₂);\n (m.1.1, m.2)",
" mapAccumr₂ f₁ (mapAccumr f₂ nil s₂).2 nil s₁ =\n let m :=\n ... |
import Mathlib.NumberTheory.ZetaValues
import Mathlib.NumberTheory.LSeries.RiemannZeta
open Complex Real Set
open scoped Nat
namespace HurwitzZeta
variable {k : ℕ} {x : ℝ}
theorem cosZeta_two_mul_nat (hk : k ≠ 0) (hx : x ∈ Icc 0 1) :
cosZeta x (2 * k) = (-1) ^ (k + 1) * (2 * π) ^ (2 * k) / 2 / (2 * k)! *
... | Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean | 100 | 110 | theorem cosZeta_two_mul_nat' (hk : k ≠ 0) (hx : x ∈ Icc (0 : ℝ) 1) :
cosZeta x (2 * k) = (-1) ^ (k + 1) / (2 * k) / Gammaℂ (2 * k) *
((Polynomial.bernoulli (2 * k)).map (algebraMap ℚ ℂ)).eval (x : ℂ) := by |
rw [cosZeta_two_mul_nat hk hx]
congr 1
have : (2 * k)! = (2 * k) * Complex.Gamma (2 * k) := by
rw [(by { norm_cast; omega } : 2 * (k : ℂ) = ↑(2 * k - 1) + 1), Complex.Gamma_nat_eq_factorial,
← Nat.cast_add_one, ← Nat.cast_mul, ← Nat.factorial_succ, Nat.sub_add_cancel (by omega)]
simp_rw [this, Gammaℂ... | [
" cosZeta (↑x) (2 * ↑k) =\n (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k) / 2 / ↑(2 * k)! *\n Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k)))",
" 1 < (2 * ↑k).re",
" ∑' (b : ℕ), ↑(2 * π * x * ↑b).cos / ↑b ^ (2 * ↑k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k) * (2 * π * ↑b * x).cos)",
... | [
" cosZeta (↑x) (2 * ↑k) =\n (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k) / 2 / ↑(2 * k)! *\n Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k)))",
" 1 < (2 * ↑k).re",
" ∑' (b : ℕ), ↑(2 * π * x * ↑b).cos / ↑b ^ (2 * ↑k) = ↑(∑' (b : ℕ), 1 / ↑b ^ (2 * k) * (2 * π * ↑b * x).cos)",
... |
import Mathlib.LinearAlgebra.GeneralLinearGroup
import Mathlib.LinearAlgebra.Matrix.Adjugate
import Mathlib.LinearAlgebra.Matrix.Transvection
import Mathlib.RingTheory.RootsOfUnity.Basic
#align_import linear_algebra.matrix.special_linear_group from "leanprover-community/mathlib"@"f06058e64b7e8397234455038f3f8aec83aab... | Mathlib/LinearAlgebra/Matrix/SpecialLinearGroup.lean | 181 | 183 | theorem det_ne_zero [Nontrivial R] (g : SpecialLinearGroup n R) : det ↑ₘg ≠ 0 := by |
rw [g.det_coe]
norm_num
| [
" Subsingleton (SpecialLinearGroup n R)",
" ⟨A, hA⟩ = ⟨B, hB⟩",
" ↑⟨A, hA⟩ i j = ↑⟨B, hB⟩ i j",
" False",
" ↑⟨A, hA✝⟩ i j = ↑⟨B, hB✝⟩ i j",
" (↑A).adjugate.det = 1",
" (↑A * ↑B).det = 1",
" (↑g).det ≠ 0",
" 1 ≠ 0"
] | [
" Subsingleton (SpecialLinearGroup n R)",
" ⟨A, hA⟩ = ⟨B, hB⟩",
" ↑⟨A, hA⟩ i j = ↑⟨B, hB⟩ i j",
" False",
" ↑⟨A, hA✝⟩ i j = ↑⟨B, hB✝⟩ i j",
" (↑A).adjugate.det = 1",
" (↑A * ↑B).det = 1"
] |
import Mathlib.Topology.Connected.Basic
import Mathlib.Topology.Separation
open scoped Topology
variable {X Y A} [TopologicalSpace X] [TopologicalSpace A]
theorem embedding_toPullbackDiag (f : X → Y) : Embedding (toPullbackDiag f) :=
Embedding.mk' _ (injective_toPullbackDiag f) fun x ↦ by
rw [toPullbackDiag,... | Mathlib/Topology/SeparatedMap.lean | 79 | 87 | theorem isSeparatedMap_iff_isClosed_diagonal {f : X → Y} :
IsSeparatedMap f ↔ IsClosed f.pullbackDiagonal := by |
simp_rw [isSeparatedMap_iff_nhds, ← isOpen_compl_iff, isOpen_iff_mem_nhds,
Subtype.forall, Prod.forall, nhds_induced, nhds_prod_eq]
refine forall₄_congr fun x₁ x₂ _ _ ↦ ⟨fun h ↦ ?_, fun ⟨t, ht, t_sub⟩ ↦ ?_⟩
· simp_rw [← Filter.disjoint_iff, ← compl_diagonal_mem_prod] at h
exact ⟨_, h, subset_rfl⟩
· obt... | [
" Filter.comap (toPullbackDiag f) (𝓝 (toPullbackDiag f x)) = 𝓝 x",
" Filter.comap (Prod.fst ∘ Subtype.val ∘ toPullbackDiag f) (𝓝 x) ⊓\n Filter.comap (Prod.snd ∘ Subtype.val ∘ toPullbackDiag f) (𝓝 x) =\n 𝓝 x",
" Continuous (Function.mapPullback mapX mapY mapZ commX commZ)",
" Continuous fun x => m... | [
" Filter.comap (toPullbackDiag f) (𝓝 (toPullbackDiag f x)) = 𝓝 x",
" Filter.comap (Prod.fst ∘ Subtype.val ∘ toPullbackDiag f) (𝓝 x) ⊓\n Filter.comap (Prod.snd ∘ Subtype.val ∘ toPullbackDiag f) (𝓝 x) =\n 𝓝 x",
" Continuous (Function.mapPullback mapX mapY mapZ commX commZ)",
" Continuous fun x => m... |
import Mathlib.Data.Finset.Lattice
import Mathlib.Data.Set.Sigma
#align_import data.finset.sigma from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Function Multiset
variable {ι : Type*}
namespace Finset
section SigmaLift
variable {α β γ : ι → Type*} [DecidableEq ι]
def sigm... | Mathlib/Data/Finset/Sigma.lean | 204 | 208 | theorem sigmaLift_eq_empty : sigmaLift f a b = ∅ ↔ ∀ h : a.1 = b.1, f (h ▸ a.2) b.2 = ∅ := by |
simp_rw [sigmaLift]
split_ifs with h
· simp [h, forall_prop_of_true h]
· simp [h, forall_prop_of_false h]
| [
" x ∈ sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)",
" x ∈ sigmaLift f ⟨i, a⟩ ⟨j, b⟩ ↔\n ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨j, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨j, b⟩.snd)",
" x ∈ sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔\n ∃ (ha : ⟨i, a⟩.fst = x.f... | [
" x ∈ sigmaLift f a b ↔ ∃ (ha : a.fst = x.fst) (hb : b.fst = x.fst), x.snd ∈ f (ha ▸ a.snd) (hb ▸ b.snd)",
" x ∈ sigmaLift f ⟨i, a⟩ ⟨j, b⟩ ↔\n ∃ (ha : ⟨i, a⟩.fst = x.fst) (hb : ⟨j, b⟩.fst = x.fst), x.snd ∈ f (ha ▸ ⟨i, a⟩.snd) (hb ▸ ⟨j, b⟩.snd)",
" x ∈ sigmaLift f ⟨i, a⟩ ⟨i, b⟩ ↔\n ∃ (ha : ⟨i, a⟩.fst = x.f... |
import Mathlib.Data.DFinsupp.Basic
import Mathlib.Data.Finset.Pointwise
import Mathlib.LinearAlgebra.Basis.VectorSpace
#align_import algebra.group.unique_prods from "leanprover-community/mathlib"@"d6fad0e5bf2d6f48da9175d25c3dc5706b3834ce"
@[to_additive
"Let `G` be a Type with addition, let `A B : Finset G` ... | Mathlib/Algebra/Group/UniqueProds.lean | 71 | 75 | theorem of_card_le_one (hA : A.Nonempty) (hB : B.Nonempty) (hA1 : A.card ≤ 1) (hB1 : B.card ≤ 1) :
∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b := by |
rw [Finset.card_le_one_iff] at hA1 hB1
obtain ⟨a, ha⟩ := hA; obtain ⟨b, hb⟩ := hB
exact ⟨a, ha, b, hb, fun _ _ ha' hb' _ ↦ ⟨hA1 ha' ha, hB1 hb' hb⟩⟩
| [
" UniqueMul A B a0 b0",
" ∃ a ∈ A, ∃ b ∈ B, UniqueMul A B a b"
] | [
" UniqueMul A B a0 b0"
] |
import Mathlib.Data.Vector.Basic
import Mathlib.Data.Vector.Snoc
set_option autoImplicit true
namespace Vector
section Fold
section Binary
variable (xs : Vector α n) (ys : Vector β n)
@[simp]
theorem mapAccumr₂_mapAccumr_left (f₁ : γ → β → σ₁ → σ₁ × ζ) (f₂ : α → σ₂ → σ₂ × γ) :
(mapAccumr₂ f₁ (mapAccumr f₂... | Mathlib/Data/Vector/MapLemmas.lean | 108 | 117 | theorem mapAccumr₂_mapAccumr₂_left_left (f₁ : γ → α → σ₁ → σ₁ × φ) (f₂ : α → β → σ₂ → σ₂ × γ) :
(mapAccumr₂ f₁ (mapAccumr₂ f₂ xs ys s₂).snd xs s₁)
= let m := mapAccumr₂ (fun x y (s₁, s₂) =>
let r₂ := f₂ x y s₂
let r₁ := f₁ r₂.snd x s₁
((r₁.fst, r₂.fst), r₁.snd)
... |
induction xs, ys using Vector.revInductionOn₂ generalizing s₁ s₂ <;> simp_all
| [
" mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).2 ys s₁ =\n let m :=\n mapAccumr₂\n (fun x y s =>\n let r₂ := f₂ x s.2;\n let r₁ := f₁ r₂.2 y s.1;\n ((r₁.1, r₂.1), r₁.2))\n xs ys (s₁, s₂);\n (m.1.1, m.2)",
" mapAccumr₂ f₁ (mapAccumr f₂ nil s₂).2 nil s₁ =\n let m :=\n ... | [
" mapAccumr₂ f₁ (mapAccumr f₂ xs s₂).2 ys s₁ =\n let m :=\n mapAccumr₂\n (fun x y s =>\n let r₂ := f₂ x s.2;\n let r₁ := f₁ r₂.2 y s.1;\n ((r₁.1, r₂.1), r₁.2))\n xs ys (s₁, s₂);\n (m.1.1, m.2)",
" mapAccumr₂ f₁ (mapAccumr f₂ nil s₂).2 nil s₁ =\n let m :=\n ... |
import Mathlib.MeasureTheory.Integral.Lebesgue
open Set hiding restrict restrict_apply
open Filter ENNReal NNReal MeasureTheory.Measure
namespace MeasureTheory
variable {α : Type*} {m0 : MeasurableSpace α} {μ : Measure α}
noncomputable
def Measure.withDensity {m : MeasurableSpace α} (μ : Measure α) (f : α → ℝ≥... | Mathlib/MeasureTheory/Measure/WithDensity.lean | 105 | 107 | theorem withDensity_add_right (f : α → ℝ≥0∞) {g : α → ℝ≥0∞} (hg : Measurable g) :
μ.withDensity (f + g) = μ.withDensity f + μ.withDensity g := by |
simpa only [add_comm] using withDensity_add_left hg f
| [
" (fun s x => ∫⁻ (a : α) in s, f a ∂μ) ∅ ⋯ = 0",
" ∫⁻ (a : α) in s, f a ∂μ ≤ (μ.withDensity f) s",
" (μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ",
" (μ.withDensity f) s ≤ ∫⁻ (a : α) in s, f a ∂μ",
" ∫⁻ (a : α) in t, f a ∂μ = ∫⁻ (a : α) in s, f a ∂μ",
" μ.restrict t = μ.restrict s",
" withDensity 0 f =... | [
" (fun s x => ∫⁻ (a : α) in s, f a ∂μ) ∅ ⋯ = 0",
" ∫⁻ (a : α) in s, f a ∂μ ≤ (μ.withDensity f) s",
" (μ.withDensity f) s = ∫⁻ (a : α) in s, f a ∂μ",
" (μ.withDensity f) s ≤ ∫⁻ (a : α) in s, f a ∂μ",
" ∫⁻ (a : α) in t, f a ∂μ = ∫⁻ (a : α) in s, f a ∂μ",
" μ.restrict t = μ.restrict s",
" withDensity 0 f =... |
import Mathlib.MeasureTheory.Constructions.Prod.Basic
import Mathlib.MeasureTheory.Integral.DominatedConvergence
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.constructions.prod.integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
noncomputable s... | Mathlib/MeasureTheory/Constructions/Prod/Integral.lean | 77 | 122 | theorem MeasureTheory.StronglyMeasurable.integral_prod_right [SigmaFinite ν] ⦃f : α → β → E⦄
(hf : StronglyMeasurable (uncurry f)) : StronglyMeasurable fun x => ∫ y, f x y ∂ν := by |
by_cases hE : CompleteSpace E; swap; · simp [integral, hE, stronglyMeasurable_const]
borelize E
haveI : SeparableSpace (range (uncurry f) ∪ {0} : Set E) :=
hf.separableSpace_range_union_singleton
let s : ℕ → SimpleFunc (α × β) E :=
SimpleFunc.approxOn _ hf.measurable (range (uncurry f) ∪ {0}) 0 (by sim... | [
" MeasurableSet {x | Integrable (f x) ν}",
" MeasurableSet {x | HasFiniteIntegral (f x) ν}",
" StronglyMeasurable fun x => ∫ (y : β), f x y ∂ν",
" 0 ∈ range (uncurry f) ∪ {0}",
" ∀ (n : ℕ), StronglyMeasurable (f' n)",
" StronglyMeasurable (f' n)",
" StronglyMeasurable fun x => SimpleFunc.integral ν (s' ... | [
" MeasurableSet {x | Integrable (f x) ν}",
" MeasurableSet {x | HasFiniteIntegral (f x) ν}"
] |
import Mathlib.Algebra.Polynomial.Degree.Definitions
import Mathlib.Algebra.Polynomial.Induction
#align_import data.polynomial.eval from "leanprover-community/mathlib"@"728baa2f54e6062c5879a3e397ac6bac323e506f"
set_option linter.uppercaseLean3 false
noncomputable section
open Finset AddMonoidAlgebra
open Polyn... | Mathlib/Algebra/Polynomial/Eval.lean | 82 | 85 | theorem eval₂_X_pow {n : ℕ} : (X ^ n).eval₂ f x = x ^ n := by |
rw [X_pow_eq_monomial]
convert eval₂_monomial f x (n := n) (r := 1)
simp
| [
" eval₂ f x p = p.sum fun e a => f a * x ^ e",
" f = g → s = t → φ = ψ → eval₂ f s φ = eval₂ g t ψ",
" eval₂ f s φ = eval₂ f s φ",
" eval₂ f 0 p = f (p.coeff 0)",
" eval₂ f x 0 = 0",
" eval₂ f x (C a) = f a",
" eval₂ f x X = x",
" eval₂ f x ((monomial n) r) = f r * x ^ n",
" eval₂ f x (X ^ n) = x ^ ... | [
" eval₂ f x p = p.sum fun e a => f a * x ^ e",
" f = g → s = t → φ = ψ → eval₂ f s φ = eval₂ g t ψ",
" eval₂ f s φ = eval₂ f s φ",
" eval₂ f 0 p = f (p.coeff 0)",
" eval₂ f x 0 = 0",
" eval₂ f x (C a) = f a",
" eval₂ f x X = x",
" eval₂ f x ((monomial n) r) = f r * x ^ n"
] |
import Mathlib.Data.Set.Image
import Mathlib.Data.List.GetD
#align_import data.set.list from "leanprover-community/mathlib"@"2ec920d35348cb2d13ac0e1a2ad9df0fdf1a76b4"
open List
variable {α β : Type*} (l : List α)
namespace Set
theorem range_list_map (f : α → β) : range (map f) = { l | ∀ x ∈ l, x ∈ range f } :=... | Mathlib/Data/Set/List.lean | 52 | 57 | theorem range_list_getD (d : α) : (range fun n => l.getD n d) = insert d { x | x ∈ l } :=
calc
(range fun n => l.getD n d) = (fun o : Option α => o.getD d) '' range l.get? := by |
simp only [← range_comp, (· ∘ ·), getD_eq_getD_get?]
_ = insert d { x | x ∈ l } := by
simp only [range_list_get?, image_insert_eq, Option.getD, image_image, image_id']
| [
" range (map f) = {l | ∀ x ∈ l, x ∈ range f}",
" l ∈ range (map f)",
" [] ∈ range (map f)",
" a :: l ∈ range (map f)",
" a :: map f l ∈ range (map f)",
" f a :: map f l ∈ range (map f)",
" range (map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}",
" range l.get = {x | x ∈ l}",
" x ∈ range l.get ↔ x ∈ {x | x ∈... | [
" range (map f) = {l | ∀ x ∈ l, x ∈ range f}",
" l ∈ range (map f)",
" [] ∈ range (map f)",
" a :: l ∈ range (map f)",
" a :: map f l ∈ range (map f)",
" f a :: map f l ∈ range (map f)",
" range (map Subtype.val) = {l | ∀ x ∈ l, x ∈ s}",
" range l.get = {x | x ∈ l}",
" x ∈ range l.get ↔ x ∈ {x | x ∈... |
import Mathlib.Analysis.Complex.RemovableSingularity
import Mathlib.Analysis.Calculus.UniformLimitsDeriv
import Mathlib.Analysis.NormedSpace.FunctionSeries
#align_import analysis.complex.locally_uniform_limit from "leanprover-community/mathlib"@"fe44cd36149e675eb5dec87acc7e8f1d6568e081"
open Set Metric MeasureThe... | Mathlib/Analysis/Complex/LocallyUniformLimit.lean | 95 | 110 | theorem _root_.TendstoUniformlyOn.cderiv (hF : TendstoUniformlyOn F f φ (cthickening δ K))
(hδ : 0 < δ) (hFn : ∀ᶠ n in φ, ContinuousOn (F n) (cthickening δ K)) :
TendstoUniformlyOn (cderiv δ ∘ F) (cderiv δ f) φ K := by |
rcases φ.eq_or_neBot with rfl | hne
· simp only [TendstoUniformlyOn, eventually_bot, imp_true_iff]
have e1 : ContinuousOn f (cthickening δ K) := TendstoUniformlyOn.continuousOn hF hFn
rw [tendstoUniformlyOn_iff] at hF ⊢
rintro ε hε
filter_upwards [hF (ε * δ) (mul_pos hε hδ), hFn] with n h h' z hz
simp_rw... | [
" ‖cderiv r f z‖ ≤ M / r",
" 0 ≤ M",
" ∀ w ∈ sphere z r, ‖((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r ^ 2",
" ‖((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r ^ 2",
" ‖f w‖ / r ^ 2 ≤ M / r ^ 2",
" ‖(2 * ↑π * I)⁻¹‖ * ‖∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r",
" ‖(2 * ↑π * I)⁻¹‖ * (2 * π * r * (M / r ^ 2)) = M / r",
" 2... | [
" ‖cderiv r f z‖ ≤ M / r",
" 0 ≤ M",
" ∀ w ∈ sphere z r, ‖((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r ^ 2",
" ‖((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r ^ 2",
" ‖f w‖ / r ^ 2 ≤ M / r ^ 2",
" ‖(2 * ↑π * I)⁻¹‖ * ‖∮ (w : ℂ) in C(z, r), ((w - z) ^ 2)⁻¹ • f w‖ ≤ M / r",
" ‖(2 * ↑π * I)⁻¹‖ * (2 * π * r * (M / r ^ 2)) = M / r",
" 2... |
import Mathlib.Order.BooleanAlgebra
import Mathlib.Logic.Equiv.Basic
#align_import order.symm_diff from "leanprover-community/mathlib"@"6eb334bd8f3433d5b08ba156b8ec3e6af47e1904"
open Function OrderDual
variable {ι α β : Type*} {π : ι → Type*}
def symmDiff [Sup α] [SDiff α] (a b : α) : α :=
a \ b ⊔ b \ a
#ali... | Mathlib/Order/SymmDiff.lean | 347 | 347 | theorem top_symmDiff' : ⊤ ∆ a = ￢a := by | simp [symmDiff]
| [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ ⊤ = ￢a",
" ⊤ ∆ a = ￢a"
] | [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ ⊤ = ￢a"
] |
import Mathlib.Algebra.Algebra.Bilinear
import Mathlib.RingTheory.Localization.Basic
#align_import algebra.module.localized_module from "leanprover-community/mathlib"@"831c494092374cfe9f50591ed0ac81a25efc5b86"
namespace LocalizedModule
universe u v
variable {R : Type u} [CommSemiring R] (S : Submonoid R)
variab... | Mathlib/Algebra/Module/LocalizedModule.lean | 132 | 135 | theorem liftOn₂_mk {α : Type*} (f : M × S → M × S → α)
(wd : ∀ (p q p' q' : M × S), p ≈ p' → q ≈ q' → f p q = f p' q') (m m' : M)
(s s' : S) : liftOn₂ (mk m s) (mk m' s') f wd = f ⟨m, s⟩ ⟨m', s'⟩ := by |
convert Quotient.liftOn₂_mk f wd _ _
| [
" 1 • (m, s).2 • (m, s).1 = 1 • (m, s).2 • (m, s).1",
" r S M (m1, s1) (m3, s3)",
" (u1 * u2 * s2) • (m3, s3).2 • (m1, s1).1 = (u1 * u2 * s2) • (m1, s1).2 • (m3, s3).1",
" (s2 * (s3 * (u1 * u2))) • m1 = (s1 * (s2 * (u1 * u2))) • m3",
" ∀ (x : LocalizedModule S M), β x",
" β (Quot.mk Setoid.r (m, s))",
"... | [
" 1 • (m, s).2 • (m, s).1 = 1 • (m, s).2 • (m, s).1",
" r S M (m1, s1) (m3, s3)",
" (u1 * u2 * s2) • (m3, s3).2 • (m1, s1).1 = (u1 * u2 * s2) • (m1, s1).2 • (m3, s3).1",
" (s2 * (s3 * (u1 * u2))) • m1 = (s1 * (s2 * (u1 * u2))) • m3",
" ∀ (x : LocalizedModule S M), β x",
" β (Quot.mk Setoid.r (m, s))",
"... |
import Mathlib.Algebra.DirectSum.Finsupp
import Mathlib.LinearAlgebra.Finsupp
import Mathlib.LinearAlgebra.DirectSum.TensorProduct
#align_import linear_algebra.direct_sum.finsupp from "leanprover-community/mathlib"@"9b9d125b7be0930f564a68f1d73ace10cf46064d"
noncomputable section
open DirectSum TensorProduct
ope... | Mathlib/LinearAlgebra/DirectSum/Finsupp.lean | 256 | 259 | theorem finsuppTensorFinsupp_single (i : ι) (m : M) (k : κ) (n : N) :
finsuppTensorFinsupp R S M N ι κ (Finsupp.single i m ⊗ₜ Finsupp.single k n) =
Finsupp.single (i, k) (m ⊗ₜ n) := by |
simp [finsuppTensorFinsupp]
| [
" (finsuppTensorFinsupp R S M N ι κ) (Finsupp.single i m ⊗ₜ[R] Finsupp.single k n) = Finsupp.single (i, k) (m ⊗ₜ[R] n)"
] | [] |
import Mathlib.Analysis.SpecialFunctions.Gaussian.GaussianIntegral
#align_import analysis.special_functions.gamma.bohr_mollerup from "leanprover-community/mathlib"@"a3209ddf94136d36e5e5c624b10b2a347cc9d090"
set_option linter.uppercaseLean3 false
noncomputable section
open Filter Set MeasureTheory
open scoped Na... | Mathlib/Analysis/SpecialFunctions/Gamma/BohrMollerup.lean | 164 | 173 | theorem convexOn_log_Gamma : ConvexOn ℝ (Ioi 0) (log ∘ Gamma) := by |
refine convexOn_iff_forall_pos.mpr ⟨convex_Ioi _, fun x hx y hy a b ha hb hab => ?_⟩
have : b = 1 - a := by linarith
subst this
simp_rw [Function.comp_apply, smul_eq_mul]
simp only [mem_Ioi] at hx hy
rw [← log_rpow, ← log_rpow, ← log_mul]
· gcongr
exact Gamma_mul_add_mul_le_rpow_Gamma_mul_rpow_Gamma ... | [
" (a * s + b * t).Gamma ≤ s.Gamma ^ a * t.Gamma ^ b",
" b = 1 - a",
" ∀ {c x : ℝ}, 0 < c → ∀ (u : ℝ), 0 < x → rexp (-x) * x ^ (u - 1) = f c u x ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) = f c u x ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) = (rexp (-c * x) * x ^ (c * (u - 1))) ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) ... | [
" (a * s + b * t).Gamma ≤ s.Gamma ^ a * t.Gamma ^ b",
" b = 1 - a",
" ∀ {c x : ℝ}, 0 < c → ∀ (u : ℝ), 0 < x → rexp (-x) * x ^ (u - 1) = f c u x ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) = f c u x ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) = (rexp (-c * x) * x ^ (c * (u - 1))) ^ (1 / c)",
" rexp (-x) * x ^ (u - 1) ... |
import Mathlib.Analysis.BoxIntegral.Partition.Basic
#align_import analysis.box_integral.partition.split from "leanprover-community/mathlib"@"6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f"
noncomputable section
open scoped Classical
open Filter
open Function Set Filter
namespace BoxIntegral
variable {ι M : Type*} {... | Mathlib/Analysis/BoxIntegral/Partition/Split.lean | 88 | 94 | theorem splitLower_def [DecidableEq ι] {i x} (h : x ∈ Ioo (I.lower i) (I.upper i))
(h' : ∀ j, I.lower j < update I.upper i x j :=
(forall_update_iff I.upper fun j y => I.lower j < y).2
⟨h.1, fun j _ => I.lower_lt_upper _⟩) :
I.splitLower i x = (⟨I.lower, update I.upper i x, h'⟩ : Box ι) := by |
simp (config := { unfoldPartialApp := true }) only [splitLower, mk'_eq_coe, min_eq_left h.2.le,
update, and_self]
| [
" ↑(I.splitLower i x) = ↑I ∩ {y | y i ≤ x}",
" (univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) = ↑I ∩ {y | y i ≤ x}",
" (y ∈ univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) ↔ y ∈ ↑I ∩ {y | y i ≤ x}",
" ((∀ (x : ι), I.lower x < y x) ∧ y i ≤ x ∧... | [
" ↑(I.splitLower i x) = ↑I ∩ {y | y i ≤ x}",
" (univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) = ↑I ∩ {y | y i ≤ x}",
" (y ∈ univ.pi fun i_1 => Ioc (I.lower i_1) (update I.upper i (min x (I.upper i)) i_1)) ↔ y ∈ ↑I ∩ {y | y i ≤ x}",
" ((∀ (x : ι), I.lower x < y x) ∧ y i ≤ x ∧... |
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 | 103 | 107 | theorem aeval_modByMonic_eq_self_of_root [Algebra R S] {p q : R[X]} (hq : q.Monic) {x : S}
(hx : aeval x q = 0) : aeval x (p %ₘ q) = aeval x p := by |
--`eval₂_modByMonic_eq_self_of_root` doesn't work here as it needs commutativity
rw [modByMonic_eq_sub_mul_div p hq, _root_.map_sub, _root_.map_mul, hx, zero_mul,
sub_zero]
| [
" p₁ %ₘ q = p₂ %ₘ q",
" p₂ %ₘ q + q * (p₂ /ₘ q + f) = p₁",
" (p₁ + p₂) %ₘ q = p₁ %ₘ q + p₂ %ₘ q",
" p₁ %ₘ q + p₂ %ₘ q + q * (p₁ /ₘ q + p₂ /ₘ q) = p₁ + p₂",
" c • p %ₘ q = c • (p %ₘ q)",
" c • (p %ₘ q) + q * c • (p /ₘ q) = c • p",
" (aeval x) (p %ₘ q) = (aeval x) p"
] | [
" p₁ %ₘ q = p₂ %ₘ q",
" p₂ %ₘ q + q * (p₂ /ₘ q + f) = p₁",
" (p₁ + p₂) %ₘ q = p₁ %ₘ q + p₂ %ₘ q",
" p₁ %ₘ q + p₂ %ₘ q + q * (p₁ /ₘ q + p₂ /ₘ q) = p₁ + p₂",
" c • p %ₘ q = c • (p %ₘ q)",
" c • (p %ₘ q) + q * c • (p /ₘ q) = c • p"
] |
import Mathlib.Algebra.Lie.BaseChange
import Mathlib.Algebra.Lie.Solvable
import Mathlib.Algebra.Lie.Quotient
import Mathlib.Algebra.Lie.Normalizer
import Mathlib.LinearAlgebra.Eigenspace.Basic
import Mathlib.Order.Filter.AtTopBot
import Mathlib.RingTheory.Artinian
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mat... | Mathlib/Algebra/Lie/Nilpotent.lean | 504 | 508 | theorem ucs_le_of_normalizer_eq_self (h : N₁.normalizer = N₁) (k : ℕ) :
(⊥ : LieSubmodule R L M).ucs k ≤ N₁ := by |
rw [← ucs_eq_self_of_normalizer_eq_self h k]
mono
simp
| [
" ucs k N₁ ≤ ucs k N₂",
" ucs 0 N₁ ≤ ucs 0 N₂",
" ucs (k + 1) N₁ ≤ ucs (k + 1) N₂",
" (ucs k N₁).normalizer ≤ (ucs k N₂).normalizer",
" ucs k N₁ = N₁",
" ucs 0 N₁ = N₁",
" ucs (k + 1) N₁ = N₁",
" ucs k ⊥ ≤ N₁",
" ucs k ⊥ ≤ ucs k N₁",
" ⊥ ≤ N₁"
] | [
" ucs k N₁ ≤ ucs k N₂",
" ucs 0 N₁ ≤ ucs 0 N₂",
" ucs (k + 1) N₁ ≤ ucs (k + 1) N₂",
" (ucs k N₁).normalizer ≤ (ucs k N₂).normalizer",
" ucs k N₁ = N₁",
" ucs 0 N₁ = N₁",
" ucs (k + 1) N₁ = N₁"
] |
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Transvection
import Mathlib.MeasureTheory.Group.LIntegral
import Mathlib.MeasureTheory.Integral.Marginal
import Mathlib.MeasureTheory.Measure.Stiel... | Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean | 92 | 92 | theorem volume_Ioc {a b : ℝ} : volume (Ioc a b) = ofReal (b - a) := by | simp [volume_val]
| [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo ↑p ↑q) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo ↑p ↑q)",
" StieltjesFunction.id.measure ↑(stdOrthonormalBasis ℝ ℝ).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped ⇑(stdOrthonorma... | [
" volume = StieltjesFunction.id.measure",
" StieltjesFunction.id.measure (Ioo ↑p ↑q) = (Measure.map (fun x => a + x) StieltjesFunction.id.measure) (Ioo ↑p ↑q)",
" StieltjesFunction.id.measure ↑(stdOrthonormalBasis ℝ ℝ).toBasis.parallelepiped = 1",
" StieltjesFunction.id.measure (parallelepiped ⇑(stdOrthonorma... |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Nat.Choose.Cast
import Mathlib.Data.Nat.Choose.Multinomial
#align_import analysis.calculus.cont_diff from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open scoped C... | Mathlib/Analysis/Calculus/ContDiff/Bounds.lean | 40 | 122 | theorem ContinuousLinearMap.norm_iteratedFDerivWithin_le_of_bilinear_aux {Du Eu Fu Gu : Type u}
[NormedAddCommGroup Du] [NormedSpace 𝕜 Du] [NormedAddCommGroup Eu] [NormedSpace 𝕜 Eu]
[NormedAddCommGroup Fu] [NormedSpace 𝕜 Fu] [NormedAddCommGroup Gu] [NormedSpace 𝕜 Gu]
(B : Eu →L[𝕜] Fu →L[𝕜] Gu) {f : Du... |
/- We argue by induction on `n`. The bound is trivial for `n = 0`. For `n + 1`, we write
the `(n+1)`-th derivative as the `n`-th derivative of the derivative `B f g' + B f' g`,
and apply the inductive assumption to each of those two terms. For this induction to make sense,
the spaces of linear maps that ... | [
" ‖iteratedFDerivWithin 𝕜 n (fun y => (B (f y)) (g y)) s x‖ ≤\n ‖B‖ *\n ∑ i ∈ Finset.range (n + 1),\n ↑(n.choose i) * ‖iteratedFDerivWithin 𝕜 i f s x‖ * ‖iteratedFDerivWithin 𝕜 (n - i) g s x‖",
" ‖iteratedFDerivWithin 𝕜 0 (fun y => (B (f y)) (g y)) s x‖ ≤\n ‖B‖ *\n ∑ i ∈ Finset.range (0... | [] |
import Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic
import Mathlib.Analysis.Normed.Group.AddCircle
import Mathlib.Algebra.CharZero.Quotient
import Mathlib.Topology.Instances.Sign
#align_import analysis.special_functions.trigonometric.angle from "leanprover-community/mathlib"@"213b0cff7bc5ab6696ee07cceec80829... | Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean | 134 | 137 | theorem neg_coe_pi : -(π : Angle) = π := by |
rw [← coe_neg, angle_eq_iff_two_pi_dvd_sub]
use -1
simp [two_mul, sub_eq_add_neg]
| [
" 0 < 2 * π",
" ↑(↑n * x) = n • ↑x",
" ↑θ = ↑ψ ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" ↑ψ = ↑θ ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" -ψ + θ ∈ AddSubgroup.zmultiples (2 * π) ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" 2 * π - 0 = 2 * π * ↑1",
" -↑π = ↑π",
" ∃ k, -π - π = 2 * π * ↑k",
" -π - π = 2 * π * ↑(-1)"
] | [
" 0 < 2 * π",
" ↑(↑n * x) = n • ↑x",
" ↑θ = ↑ψ ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" ↑ψ = ↑θ ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" -ψ + θ ∈ AddSubgroup.zmultiples (2 * π) ↔ ∃ k, θ - ψ = 2 * π * ↑k",
" 2 * π - 0 = 2 * π * ↑1"
] |
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 | 92 | 96 | theorem SupIndep.le_sup_iff (hs : s.SupIndep f) (hts : t ⊆ s) (hi : i ∈ s) (hf : ∀ i, f i ≠ ⊥) :
f i ≤ t.sup f ↔ i ∈ t := by |
refine ⟨fun h => ?_, le_sup⟩
by_contra hit
exact hf i (disjoint_self.1 <| (hs hts hi hit).mono_right h)
| [
" 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.Algebra.Order.Monoid.OrderDual
import Mathlib.Tactic.Lift
import Mathlib.Tactic.Monotonicity.Attr
open Function
variable {β G M : Type*}
section Monoid
variable [Monoid M]
section Preorder
variable [Preorder M]
section Left
variable [CovariantClass M M (· * ·) (· ≤ ·)] {x : M}
@[to_additive (... | Mathlib/Algebra/Order/Monoid/Unbundled/Pow.lean | 71 | 77 | theorem one_lt_pow' {a : M} (ha : 1 < a) {k : ℕ} (hk : k ≠ 0) : 1 < a ^ k := by |
rcases Nat.exists_eq_succ_of_ne_zero hk with ⟨l, rfl⟩
clear hk
induction' l with l IH
· rw [pow_succ]; simpa using ha
· rw [pow_succ]
exact one_lt_mul'' IH ha
| [
" a ^ 0 ≤ b ^ 0",
" a ^ (k + 1) ≤ b ^ (k + 1)",
" a ^ k * a ≤ b ^ k * b",
" 1 ≤ a ^ 0",
" 1 ≤ a ^ (k + 1)",
" 1 ≤ a ^ k * a",
" a ^ n * a ^ k = a ^ m",
" 1 < a ^ k",
" 1 < a ^ l.succ",
" 1 < a ^ Nat.succ 0",
" 1 < a ^ 0 * a",
" 1 < a ^ (l + 1).succ",
" 1 < a ^ (l + 1) * a"
] | [
" a ^ 0 ≤ b ^ 0",
" a ^ (k + 1) ≤ b ^ (k + 1)",
" a ^ k * a ≤ b ^ k * b",
" 1 ≤ a ^ 0",
" 1 ≤ a ^ (k + 1)",
" 1 ≤ a ^ k * a",
" a ^ n * a ^ k = a ^ m"
] |
import Mathlib.Algebra.Polynomial.Basic
#align_import data.polynomial.monomial from "leanprover-community/mathlib"@"220f71ba506c8958c9b41bd82226b3d06b0991e8"
noncomputable section
namespace Polynomial
open Polynomial
universe u
variable {R : Type u} {a b : R} {m n : ℕ}
variable [Semiring R] {p q r : R[X]}
th... | Mathlib/Algebra/Polynomial/Monomial.lean | 39 | 56 | theorem card_support_le_one_iff_monomial {f : R[X]} :
Finset.card f.support ≤ 1 ↔ ∃ n a, f = monomial n a := by |
constructor
· intro H
rw [Finset.card_le_one_iff_subset_singleton] at H
rcases H with ⟨n, hn⟩
refine ⟨n, f.coeff n, ?_⟩
ext i
by_cases hi : i = n
· simp [hi, coeff_monomial]
· have : f.coeff i = 0 := by
rw [← not_mem_support_iff]
exact fun hi' => hi (Finset.mem_singleton... | [
" (monomial i) 1 = (monomial j) 1 ↔ i = j",
" Finsupp.single i 1 = Finsupp.single j 1 ↔ i = j",
" m = n",
" f.support.card ≤ 1 ↔ ∃ n a, f = (monomial n) a",
" f.support.card ≤ 1 → ∃ n a, f = (monomial n) a",
" ∃ n a, f = (monomial n) a",
" f = (monomial n) (f.coeff n)",
" f.coeff i = ((monomial n) (f.... | [
" (monomial i) 1 = (monomial j) 1 ↔ i = j",
" Finsupp.single i 1 = Finsupp.single j 1 ↔ i = j",
" m = n"
] |
import Mathlib.Algebra.Group.Conj
import Mathlib.Algebra.Group.Pi.Lemmas
import Mathlib.Algebra.Group.Subsemigroup.Operations
import Mathlib.Algebra.Group.Submonoid.Operations
import Mathlib.Algebra.Order.Group.Abs
import Mathlib.Data.Set.Image
import Mathlib.Order.Atoms
import Mathlib.Tactic.ApplyFun
#align_import g... | Mathlib/Algebra/Group/Subgroup/Basic.lean | 144 | 145 | theorem div_mem {x y : M} (hx : x ∈ H) (hy : y ∈ H) : x / y ∈ H := by |
rw [div_eq_mul_inv]; exact mul_mem hx (inv_mem hy)
| [
" |x| ∈ H ↔ x ∈ H",
" x / y ∈ H",
" x * y⁻¹ ∈ H"
] | [
" |x| ∈ H ↔ x ∈ H"
] |
import Mathlib.Data.Nat.Prime
import Mathlib.Tactic.NormNum.Basic
#align_import data.nat.prime_norm_num from "leanprover-community/mathlib"@"10b4e499f43088dd3bb7b5796184ad5216648ab1"
open Nat Qq Lean Meta
namespace Mathlib.Meta.NormNum
theorem not_prime_mul_of_ble (a b n : ℕ) (h : a * b = n) (h₁ : a.ble 1 = fals... | Mathlib/Tactic/NormNum/Prime.lean | 90 | 95 | theorem minFacHelper_3 {n k k' : ℕ} (e : k + 2 = k') (nk : (n % k).beq 0 = false)
(h : MinFacHelper n k) : MinFacHelper n k' := by |
refine minFacHelper_1 e h λ h2 ↦ ?_
have nk := Nat.ne_of_beq_eq_false nk
rw [← Nat.dvd_iff_mod_eq_zero, ← h2] at nk
exact nk <| minFac_dvd n
| [
" 1 < n",
" 1 < 0",
" 1 < succ 0",
" MinFacHelper n 3",
" 2 < 3",
" 3 % 2 = 1",
" 3 ≤ n.minFac",
" 3 ≤ p",
" 3 ≤ 2",
" MinFacHelper n k'",
" MinFacHelper n (k + 2)",
" (k + 2) % 2 = 1",
" k % 2 = 1",
" k + 2 ≤ n.minFac",
" n.minFac + 2 ≤ n.minFac",
" 2 = n.minFac",
" 2 ∣ n.minFac",
... | [
" 1 < n",
" 1 < 0",
" 1 < succ 0",
" MinFacHelper n 3",
" 2 < 3",
" 3 % 2 = 1",
" 3 ≤ n.minFac",
" 3 ≤ p",
" 3 ≤ 2",
" MinFacHelper n k'",
" MinFacHelper n (k + 2)",
" (k + 2) % 2 = 1",
" k % 2 = 1",
" k + 2 ≤ n.minFac",
" n.minFac + 2 ≤ n.minFac",
" 2 = n.minFac",
" 2 ∣ n.minFac",
... |
import Mathlib.Analysis.NormedSpace.OperatorNorm.Bilinear
import Mathlib.Analysis.NormedSpace.OperatorNorm.NNNorm
import Mathlib.Analysis.NormedSpace.Span
suppress_compilation
open Bornology
open Filter hiding map_smul
open scoped Classical NNReal Topology Uniformity
-- the `ₗ` subscript variables are for special... | Mathlib/Analysis/NormedSpace/OperatorNorm/NormedSpace.lean | 99 | 107 | theorem opNorm_zero_iff [RingHomIsometric σ₁₂] : ‖f‖ = 0 ↔ f = 0 :=
Iff.intro
(fun hn => ContinuousLinearMap.ext fun x => norm_le_zero_iff.1
(calc
_ ≤ ‖f‖ * ‖x‖ := le_opNorm _ _
_ = _ := by | rw [hn, zero_mul]))
(by
rintro rfl
exact opNorm_zero)
| [
" ‖f‖ * ‖x‖ = 0",
" f = 0 → ‖f‖ = 0",
" ‖0‖ = 0"
] | [] |
import Mathlib.CategoryTheory.Filtered.Basic
import Mathlib.Topology.Category.TopCat.Limits.Basic
#align_import topology.category.Top.limits.konig from "leanprover-community/mathlib"@"dbdf71cee7bb20367cb7e37279c08b0c218cf967"
-- Porting note: every ML3 decl has an uppercase letter
set_option linter.uppercaseLean3 ... | Mathlib/Topology/Category/TopCat/Limits/Konig.lean | 107 | 124 | theorem partialSections.closed [∀ j : J, T2Space (F.obj j)] {G : Finset J}
(H : Finset (FiniteDiagramArrow G)) : IsClosed (partialSections F H) := by |
have :
partialSections F H =
⋂ (f : FiniteDiagramArrow G) (_ : f ∈ H), {u | F.map f.2.2.2.2 (u f.1) = u f.2.1} := by
ext1
simp only [Set.mem_iInter, Set.mem_setOf_eq]
rfl
rw [this]
apply isClosed_biInter
intro f _
-- Porting note: can't see through forget
have : T2Space ((forget TopCa... | [
" (partialSections F H).Nonempty",
" (fun j => if hj : j ∈ G then (F.map (IsCofiltered.infTo G H hj)) ⋯.some else ⋯.some) ∈ partialSections F H",
" (F.map ⟨X, ⟨Y, ⟨hX, ⟨hY, f⟩⟩⟩⟩.snd.snd.snd.snd)\n ((fun j => if hj : j ∈ G then (F.map (IsCofiltered.infTo G H hj)) ⋯.some else ⋯.some)\n ⟨X, ⟨Y, ⟨hX, ⟨... | [
" (partialSections F H).Nonempty",
" (fun j => if hj : j ∈ G then (F.map (IsCofiltered.infTo G H hj)) ⋯.some else ⋯.some) ∈ partialSections F H",
" (F.map ⟨X, ⟨Y, ⟨hX, ⟨hY, f⟩⟩⟩⟩.snd.snd.snd.snd)\n ((fun j => if hj : j ∈ G then (F.map (IsCofiltered.infTo G H hj)) ⋯.some else ⋯.some)\n ⟨X, ⟨Y, ⟨hX, ⟨... |
import Mathlib.Algebra.Polynomial.Mirror
import Mathlib.Analysis.Complex.Polynomial
#align_import data.polynomial.unit_trinomial from "leanprover-community/mathlib"@"302eab4f46abb63de520828de78c04cb0f9b5836"
namespace Polynomial
open scoped Polynomial
open Finset
section Semiring
variable {R : Type*} [Semirin... | Mathlib/Algebra/Polynomial/UnitTrinomial.lean | 100 | 102 | theorem trinomial_trailingCoeff (hkm : k < m) (hmn : m < n) (hu : u ≠ 0) :
(trinomial k m n u v w).trailingCoeff = u := by |
rw [trailingCoeff, trinomial_natTrailingDegree hkm hmn hu, trinomial_trailing_coeff' hkm hmn]
| [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u",
" (trinomial k m n u v w).natDegree = n",
" (trinomial k m n u v w).coeff n ≠ 0",
" ↑i ≤ ↑n",
" ↑i ≤ ↑i",
" (trinomial k m n u v w).natTrailingDegree = k",
" (trinomial k m n u v w... | [
" (trinomial k m n u v w).coeff n = w",
" (trinomial k m n u v w).coeff m = v",
" (trinomial k m n u v w).coeff k = u",
" (trinomial k m n u v w).natDegree = n",
" (trinomial k m n u v w).coeff n ≠ 0",
" ↑i ≤ ↑n",
" ↑i ≤ ↑i",
" (trinomial k m n u v w).natTrailingDegree = k",
" (trinomial k m n u v w... |
import Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv
#align_import linear_algebra.quadratic_form.prod from "leanprover-community/mathlib"@"9b2755b951bc323c962bd072cd447b375cf58101"
universe u v w
variable {ι : Type*} {R : Type*} {M₁ M₂ N₁ N₂ : Type*} {Mᵢ Nᵢ : ι → Type*}
namespace QuadraticForm
section Pro... | Mathlib/LinearAlgebra/QuadraticForm/Prod.lean | 328 | 339 | theorem nonneg_pi_iff [Fintype ι] {R} [OrderedCommRing R] [∀ i, Module R (Mᵢ i)]
{Q : ∀ i, QuadraticForm R (Mᵢ i)} : (∀ x, 0 ≤ pi Q x) ↔ ∀ i x, 0 ≤ Q i x := by |
simp_rw [pi, sum_apply, comp_apply, LinearMap.proj_apply]
constructor
-- TODO: does this generalize to a useful lemma independent of `QuadraticForm`?
· intro h i x
classical
convert h (Pi.single i x) using 1
rw [Finset.sum_eq_single_of_mem i (Finset.mem_univ _) fun j _ hji => ?_, Pi.single_eq_same]... | [
" (pi Q) (Pi.single i m) = (Q i) m",
" (Q j) (Pi.single i m j) = 0",
" (QuadraticForm.pi Q') ((↑(LinearEquiv.piCongrRight fun i => (e i).toLinearEquiv)).toFun x) = (QuadraticForm.pi Q) x",
" Q ((LinearMap.proj i).toFun m) = (pi (Pi.single i Q)) m",
" Q (m i) = (pi (Pi.single i Q)) m",
" (Pi.single i Q j) ... | [
" (pi Q) (Pi.single i m) = (Q i) m",
" (Q j) (Pi.single i m j) = 0",
" (QuadraticForm.pi Q') ((↑(LinearEquiv.piCongrRight fun i => (e i).toLinearEquiv)).toFun x) = (QuadraticForm.pi Q) x",
" Q ((LinearMap.proj i).toFun m) = (pi (Pi.single i Q)) m",
" Q (m i) = (pi (Pi.single i Q)) m",
" (Pi.single i Q j) ... |
import Mathlib.Analysis.Calculus.FDeriv.Linear
import Mathlib.Analysis.Calculus.FDeriv.Comp
#align_import analysis.calculus.fderiv.add from "leanprover-community/mathlib"@"e3fb84046afd187b710170887195d50bada934ee"
open Filter Asymptotics ContinuousLinearMap Set Metric
open scoped Classical
open Topology NNReal F... | Mathlib/Analysis/Calculus/FDeriv/Add.lean | 353 | 357 | theorem HasFDerivAtFilter.sum (h : ∀ i ∈ u, HasFDerivAtFilter (A i) (A' i) x L) :
HasFDerivAtFilter (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x L := by |
simp only [hasFDerivAtFilter_iff_isLittleO] at *
convert IsLittleO.sum h
simp [ContinuousLinearMap.sum_apply]
| [
" HasStrictFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x",
" (fun p => ∑ i ∈ u, A i p.1 - ∑ i ∈ u, A i p.2 - (∑ i ∈ u, A' i) (p.1 - p.2)) =o[𝓝 (x, x)] fun p => p.1 - p.2",
" ∑ i ∈ u, A i x✝.1 - ∑ i ∈ u, A i x✝.2 - (∑ i ∈ u, A' i) (x✝.1 - x✝.2) =\n ∑ i ∈ u, (A i x✝.1 - A i x✝.2 - (A' i) (x✝.1 - x✝.2))... | [
" HasStrictFDerivAt (fun y => ∑ i ∈ u, A i y) (∑ i ∈ u, A' i) x",
" (fun p => ∑ i ∈ u, A i p.1 - ∑ i ∈ u, A i p.2 - (∑ i ∈ u, A' i) (p.1 - p.2)) =o[𝓝 (x, x)] fun p => p.1 - p.2",
" ∑ i ∈ u, A i x✝.1 - ∑ i ∈ u, A i x✝.2 - (∑ i ∈ u, A' i) (x✝.1 - x✝.2) =\n ∑ i ∈ u, (A i x✝.1 - A i x✝.2 - (A' i) (x✝.1 - x✝.2))... |
import Mathlib.Geometry.Manifold.Sheaf.Smooth
import Mathlib.Geometry.RingedSpace.LocallyRingedSpace
noncomputable section
universe u
variable {𝕜 : Type u} [NontriviallyNormedField 𝕜] [CompleteSpace 𝕜]
{EM : Type*} [NormedAddCommGroup EM] [NormedSpace 𝕜 EM]
{HM : Type*} [TopologicalSpace HM] (IM : ModelWit... | Mathlib/Geometry/Manifold/Sheaf/LocallyRingedSpace.lean | 43 | 98 | theorem smoothSheafCommRing.isUnit_stalk_iff {x : M}
(f : (smoothSheafCommRing IM 𝓘(𝕜) M 𝕜).presheaf.stalk x) :
IsUnit f ↔ f ∉ RingHom.ker (smoothSheafCommRing.eval IM 𝓘(𝕜) M 𝕜 x) := by |
constructor
· rintro ⟨⟨f, g, hf, hg⟩, rfl⟩ (h' : smoothSheafCommRing.eval IM 𝓘(𝕜) M 𝕜 x f = 0)
simpa [h'] using congr_arg (smoothSheafCommRing.eval IM 𝓘(𝕜) M 𝕜 x) hf
· let S := (smoothSheafCommRing IM 𝓘(𝕜) M 𝕜).presheaf
-- Suppose that `f`, in the stalk at `x`, is nonzero at `x`
rintro (hf :... | [
" IsUnit f ↔ f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x)",
" IsUnit f → f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x)",
" False",
" f ∉ RingHom.ker (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) → IsUnit f",
" IsUnit f",
" IsUnit ((S.germ ⟨x, hxU⟩) f)",
" f ⟨x, hxU⟩ ≠ 0",
" f ⟨x, hxU⟩ = (eval IM 𝓘(𝕜, 𝕜) M 𝕜 x) ((S.ger... | [] |
import Mathlib.Algebra.Order.ToIntervalMod
import Mathlib.Algebra.Ring.AddAut
import Mathlib.Data.Nat.Totient
import Mathlib.GroupTheory.Divisible
import Mathlib.Topology.Connected.PathConnected
import Mathlib.Topology.IsLocalHomeomorph
#align_import topology.instances.add_circle from "leanprover-community/mathlib"@"... | Mathlib/Topology/Instances/AddCircle.lean | 64 | 79 | theorem continuous_right_toIcoMod : ContinuousWithinAt (toIcoMod hp a) (Ici x) x := by |
intro s h
rw [Filter.mem_map, mem_nhdsWithin_iff_exists_mem_nhds_inter]
haveI : Nontrivial 𝕜 := ⟨⟨0, p, hp.ne⟩⟩
simp_rw [mem_nhds_iff_exists_Ioo_subset] at h ⊢
obtain ⟨l, u, hxI, hIs⟩ := h
let d := toIcoDiv hp a x • p
have hd := toIcoMod_mem_Ico hp a x
simp_rw [subset_def, mem_inter_iff]
refine ⟨_, ... | [
" ContinuousWithinAt (toIcoMod hp a) (Ici x) x",
" s ∈ Filter.map (toIcoMod hp a) (𝓝[≥] x)",
" ∃ u ∈ 𝓝 x, u ∩ Ici x ⊆ toIcoMod hp a ⁻¹' s",
" ∃ u, (∃ l u_1, x ∈ Ioo l u_1 ∧ Ioo l u_1 ⊆ u) ∧ u ∩ Ici x ⊆ toIcoMod hp a ⁻¹' s",
" ∃ u,\n (∃ l u_1, x ∈ Ioo l u_1 ∧ ∀ x ∈ Ioo l u_1, x ∈ u) ∧ ∀ (x_1 : 𝕜), x_1 ... | [] |
import Mathlib.Algebra.GroupWithZero.Units.Lemmas
import Mathlib.Algebra.Order.BigOperators.Group.Finset
import Mathlib.Data.Fintype.BigOperators
#align_import data.sign from "leanprover-community/mathlib"@"2445c98ae4b87eabebdde552593519b9b6dc350c"
-- Porting note (#11081): cannot automatically derive Fintype, adde... | Mathlib/Data/Sign.lean | 165 | 165 | theorem nonneg_iff_ne_neg_one {a : SignType} : 0 ≤ a ↔ a ≠ -1 := by | cases a <;> decide
| [
" x ∈ ↑[zero, neg, pos]",
" zero ∈ ↑[zero, neg, pos]",
" neg ∈ ↑[zero, neg, pos]",
" pos ∈ ↑[zero, neg, pos]",
" Decidable (a.LE b)",
" Decidable (SignType.zero.LE b)",
" Decidable (neg.LE b)",
" Decidable (pos.LE b)",
" Decidable (SignType.zero.LE SignType.zero)",
" SignType.zero.LE SignType.zero... | [
" x ∈ ↑[zero, neg, pos]",
" zero ∈ ↑[zero, neg, pos]",
" neg ∈ ↑[zero, neg, pos]",
" pos ∈ ↑[zero, neg, pos]",
" Decidable (a.LE b)",
" Decidable (SignType.zero.LE b)",
" Decidable (neg.LE b)",
" Decidable (pos.LE b)",
" Decidable (SignType.zero.LE SignType.zero)",
" SignType.zero.LE SignType.zero... |
import Mathlib.Algebra.Polynomial.Degree.Definitions
#align_import ring_theory.polynomial.opposites from "leanprover-community/mathlib"@"63417e01fbc711beaf25fa73b6edb395c0cfddd0"
open Polynomial
open Polynomial MulOpposite
variable {R : Type*} [Semiring R]
noncomputable section
namespace Polynomial
def opRi... | Mathlib/RingTheory/Polynomial/Opposites.lean | 110 | 114 | theorem natDegree_opRingEquiv (p : R[X]ᵐᵒᵖ) : (opRingEquiv R p).natDegree = (unop p).natDegree := by |
by_cases p0 : p = 0
· simp only [p0, _root_.map_zero, natDegree_zero, unop_zero]
· simp only [p0, natDegree_eq_support_max', Ne, AddEquivClass.map_eq_zero_iff, not_false_iff,
support_opRingEquiv, unop_eq_zero_iff]
| [
" (opRingEquiv R) (op ((monomial n) r)) = (monomial n) (op r)",
" (opRingEquiv R) (op (C r * X ^ n)) = C (op r) * X ^ n",
" (opRingEquiv R) ((opRingEquiv R).symm ((monomial n) r)) = (opRingEquiv R) (op ((monomial n) r.unop))",
" (opRingEquiv R).symm (C r * X ^ n) = op (C r.unop * X ^ n)",
" ((opRingEquiv R)... | [
" (opRingEquiv R) (op ((monomial n) r)) = (monomial n) (op r)",
" (opRingEquiv R) (op (C r * X ^ n)) = C (op r) * X ^ n",
" (opRingEquiv R) ((opRingEquiv R).symm ((monomial n) r)) = (opRingEquiv R) (op ((monomial n) r.unop))",
" (opRingEquiv R).symm (C r * X ^ n) = op (C r.unop * X ^ n)",
" ((opRingEquiv R)... |
import Mathlib.Algebra.CharP.Basic
import Mathlib.Algebra.CharP.Algebra
import Mathlib.Data.Nat.Prime
#align_import algebra.char_p.exp_char from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe u
variable (R : Type u)
section Semiring
variable [Semiring R]
class inductive Ex... | Mathlib/Algebra/CharP/ExpChar.lean | 105 | 108 | theorem char_zero_of_expChar_one (p : ℕ) [hp : CharP R p] [hq : ExpChar R 1] : p = 0 := by |
cases hq
· exact CharP.eq R hp inferInstance
· exact False.elim (CharP.char_ne_one R 1 rfl)
| [
" ExpChar (R × S) p",
" ExpChar (R × S) 1",
" p = q",
" 1 = q",
" ringExpChar R = q",
" ringExpChar R = 1",
" max 0 1 = 1",
" max q 1 = q",
" q = 1",
" 1 = 1",
" p = q ↔ p.Prime",
" p = 1 ↔ p.Prime",
" 0 = 1 ↔ Nat.Prime 0",
" p = 0"
] | [
" ExpChar (R × S) p",
" ExpChar (R × S) 1",
" p = q",
" 1 = q",
" ringExpChar R = q",
" ringExpChar R = 1",
" max 0 1 = 1",
" max q 1 = q",
" q = 1",
" 1 = 1",
" p = q ↔ p.Prime",
" p = 1 ↔ p.Prime",
" 0 = 1 ↔ Nat.Prime 0"
] |
import Mathlib.Analysis.SpecialFunctions.Log.Deriv
import Mathlib.MeasureTheory.Integral.FundThmCalculus
#align_import analysis.special_functions.non_integrable from "leanprover-community/mathlib"@"55ec6e9af7d3e0043f57e394cb06a72f6275273e"
open scoped MeasureTheory Topology Interval NNReal ENNReal
open MeasureTh... | Mathlib/Analysis/SpecialFunctions/NonIntegrable.lean | 52 | 96 | theorem not_integrableOn_of_tendsto_norm_atTop_of_deriv_isBigO_filter_aux
[CompleteSpace E] {f : ℝ → E} {g : ℝ → F}
{k : Set ℝ} (l : Filter ℝ) [NeBot l] [TendstoIxxClass Icc l l]
(hl : k ∈ l) (hd : ∀ᶠ x in l, DifferentiableAt ℝ f x) (hf : Tendsto (fun x => ‖f x‖) l atTop)
(hfg : deriv f =O[l] g) : ¬Inte... |
intro hgi
obtain ⟨C, hC₀, s, hsl, hsub, hfd, hg⟩ :
∃ (C : ℝ) (_ : 0 ≤ C), ∃ s ∈ l, (∀ x ∈ s, ∀ y ∈ s, [[x, y]] ⊆ k) ∧
(∀ x ∈ s, ∀ y ∈ s, ∀ z ∈ [[x, y]], DifferentiableAt ℝ f z) ∧
∀ x ∈ s, ∀ y ∈ s, ∀ z ∈ [[x, y]], ‖deriv f z‖ ≤ C * ‖g z‖ := by
rcases hfg.exists_nonneg with ⟨C, C₀, hC⟩
have... | [
" ¬IntegrableOn g k volume",
" False",
" ∃ C,\n ∃ (_ : 0 ≤ C),\n ∃ s ∈ l,\n (∀ x ∈ s, ∀ y ∈ s, [[x, y]] ⊆ k) ∧\n (∀ x ∈ s, ∀ y ∈ s, ∀ z ∈ [[x, y]], DifferentiableAt ℝ f z) ∧\n ∀ x ∈ s, ∀ y ∈ s, ∀ z ∈ [[x, y]], ‖deriv f z‖ ≤ C * ‖g z‖",
" IntegrableOn (fun x => C * ‖g x‖) k v... | [] |
import Mathlib.Algebra.Group.ConjFinite
import Mathlib.Data.Fintype.BigOperators
import Mathlib.Dynamics.PeriodicPts
import Mathlib.GroupTheory.Commutator
import Mathlib.GroupTheory.Coset
import Mathlib.GroupTheory.GroupAction.ConjAct
import Mathlib.GroupTheory.GroupAction.Hom
#align_import group_theory.group_action.... | Mathlib/GroupTheory/GroupAction/Quotient.lean | 120 | 123 | theorem _root_.QuotientGroup.out'_conj_pow_minimalPeriod_mem (a : α) (q : α ⧸ H) :
q.out'⁻¹ * a ^ Function.minimalPeriod (a • ·) q * q.out' ∈ H := by |
rw [mul_assoc, ← QuotientGroup.eq', QuotientGroup.out_eq', ← smul_eq_mul, Quotient.mk_smul_out',
eq_comm, pow_smul_eq_iff_minimalPeriod_dvd]
| [
" (x✝³ • x✝²)⁻¹ * x✝³ • x✝¹ ∈ H",
" (b • c)⁻¹ * b • x✝¹ ∈ H",
" ↑(b • Quotient.out' q) = b • q",
" (Quotient.out' q)⁻¹ * a ^ minimalPeriod (fun x => a • x) q * Quotient.out' q ∈ H"
] | [
" (x✝³ • x✝²)⁻¹ * x✝³ • x✝¹ ∈ H",
" (b • c)⁻¹ * b • x✝¹ ∈ H",
" ↑(b • Quotient.out' q) = b • q"
] |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.NormedSpace.FiniteDimension
#align_import analysis.calculus.bump_function_inner from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
open Function Set Filter
open scoped Topology Filter
variable... | Mathlib/Analysis/Calculus/BumpFunction/Basic.lean | 172 | 176 | theorem support_eq : Function.support f = Metric.ball c f.rOut := by |
simp only [toFun, support_comp_eq_preimage, ContDiffBumpBase.support _ _ f.one_lt_rOut_div_rIn]
ext x
simp only [mem_ball_iff_norm, sub_zero, norm_smul, mem_preimage, Real.norm_eq_abs, abs_inv,
abs_of_pos f.rIn_pos, ← div_eq_inv_mul, div_lt_div_right f.rIn_pos]
| [
" 1 < f.rOut / f.rIn",
" f.rIn < f.rOut",
" ↑f (c - x) = ↑f (c + x)",
" ↑f (-x) = ↑f x",
" ↑f x = 1",
" ‖(fun x => f.rIn⁻¹ • (x - c)) x‖ ≤ 1",
" support ↑f = ball c f.rOut",
" (fun x => f.rIn⁻¹ • (x - c)) ⁻¹' ball 0 (f.rOut / f.rIn) = ball c f.rOut",
" x ∈ (fun x => f.rIn⁻¹ • (x - c)) ⁻¹' ball 0 (f.... | [
" 1 < f.rOut / f.rIn",
" f.rIn < f.rOut",
" ↑f (c - x) = ↑f (c + x)",
" ↑f (-x) = ↑f x",
" ↑f x = 1",
" ‖(fun x => f.rIn⁻¹ • (x - c)) x‖ ≤ 1"
] |
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Lp
import Mathlib.MeasureTheory.Integral.Bochner
import Mathlib.Order.Filter.IndicatorFunction
import Mathlib.MeasureTheory.Function.StronglyMeasurable.Inner
import Mathlib.MeasureTheory.Function.LpSeminorm.Trim
#align_import measure_theory.function.conditional... | Mathlib/MeasureTheory/Function/ConditionalExpectation/AEMeasurable.lean | 86 | 92 | theorem sub [AddGroup β] [TopologicalAddGroup β] {f g : α → β} (hfm : AEStronglyMeasurable' m f μ)
(hgm : AEStronglyMeasurable' m g μ) : AEStronglyMeasurable' m (f - g) μ := by |
rcases hfm with ⟨f', hf'_meas, hf_ae⟩
rcases hgm with ⟨g', hg'_meas, hg_ae⟩
refine ⟨f' - g', hf'_meas.sub hg'_meas, hf_ae.mp (hg_ae.mono fun x hx1 hx2 => ?_)⟩
simp_rw [Pi.sub_apply]
rw [hx1, hx2]
| [
" AEStronglyMeasurable' m g μ",
" AEStronglyMeasurable' m (f + g) μ",
" AEStronglyMeasurable' m (-f) μ",
" (-f) x = (-f') x",
" -f x = -f' x",
" AEStronglyMeasurable' m (f - g) μ",
" (f - g) x = (f' - g') x",
" f x - g x = f' x - g' x"
] | [
" AEStronglyMeasurable' m g μ",
" AEStronglyMeasurable' m (f + g) μ",
" AEStronglyMeasurable' m (-f) μ",
" (-f) x = (-f') x",
" -f x = -f' x"
] |
import Mathlib.MeasureTheory.Constructions.BorelSpace.Order
#align_import measure_theory.constructions.borel_space.basic from "leanprover-community/mathlib"@"9f55d0d4363ae59948c33864cbc52e0b12e0e8ce"
open Set Filter MeasureTheory MeasurableSpace
open scoped Classical Topology NNReal ENNReal MeasureTheory
univers... | Mathlib/MeasureTheory/Constructions/BorelSpace/Real.lean | 68 | 74 | theorem borel_eq_generateFrom_Iic_rat : borel ℝ = .generateFrom (⋃ a : ℚ, {Iic (a : ℝ)}) := by |
rw [borel_eq_generateFrom_Ioi_rat, iUnion_singleton_eq_range, iUnion_singleton_eq_range]
refine le_antisymm (generateFrom_le ?_) (generateFrom_le ?_) <;>
rintro _ ⟨q, rfl⟩ <;>
dsimp only <;>
[rw [← compl_Iic]; rw [← compl_Ioi]] <;>
exact MeasurableSet.compl (GenerateMeasurable.basic _ (mem_range_self q))
| [
" borel ℝ = generateFrom (⋃ a, {Iio ↑a})",
" generateFrom (range Iio) = generateFrom (⋃ a, {Iio ↑a})",
" ∀ t ∈ range Iio, MeasurableSet t",
" MeasurableSet (Iio a)",
" IsLUB (range Rat.cast ∩ Iio a) a",
" MeasurableSet (⋃ y ∈ Rat.cast ⁻¹' Iio a, Iio ↑y)",
" Iio ↑b ∈ ⋃ a, {Iio ↑a}",
" borel ℝ = generat... | [
" borel ℝ = generateFrom (⋃ a, {Iio ↑a})",
" generateFrom (range Iio) = generateFrom (⋃ a, {Iio ↑a})",
" ∀ t ∈ range Iio, MeasurableSet t",
" MeasurableSet (Iio a)",
" IsLUB (range Rat.cast ∩ Iio a) a",
" MeasurableSet (⋃ y ∈ Rat.cast ⁻¹' Iio a, Iio ↑y)",
" Iio ↑b ∈ ⋃ a, {Iio ↑a}",
" borel ℝ = generat... |
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 | 139 | 142 | theorem not_isDiag_mk_of_mem_offDiag {a : α × α} (h : a ∈ s.offDiag) :
¬ (Sym2.mk a).IsDiag := by |
rw [Sym2.isDiag_iff_proj_eq]
exact (mem_offDiag.1 h).2.2
| [
" 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.Data.List.OfFn
import Mathlib.Data.List.Range
#align_import data.list.fin_range from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
universe u
open List
| Mathlib/Data/List/FinRange.lean | 79 | 82 | theorem Equiv.Perm.map_finRange_perm {n : ℕ} (σ : Equiv.Perm (Fin n)) :
map σ (finRange n) ~ finRange n := by |
rw [perm_ext_iff_of_nodup ((nodup_finRange n).map σ.injective) <| nodup_finRange n]
simpa [mem_map, mem_finRange, true_and_iff, iff_true_iff] using σ.surjective
| [
" map (⇑σ) (finRange n) ~ finRange n",
" ∀ (a : Fin n), a ∈ map (⇑σ) (finRange n) ↔ a ∈ finRange n"
] | [] |
import Mathlib.Order.Filter.Cofinite
import Mathlib.Order.ZornAtoms
#align_import order.filter.ultrafilter from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
universe u v
variable {α : Type u} {β : Type v} {γ : Type*}
open Set Filter Function
open scoped Classical
open Filter
inst... | Mathlib/Order/Filter/Ultrafilter.lean | 135 | 135 | theorem compl_mem_iff_not_mem : sᶜ ∈ f ↔ s ∉ f := by | rw [← compl_not_mem_iff, compl_compl]
| [
" { toFilter := f, neBot' := h₁, le_of_le := h₂ } = { toFilter := g, neBot' := neBot'✝, le_of_le := le_of_le✝ }",
" (↑f ⊓ g).NeBot",
" Disjoint (↑f) g ↔ ¬↑f ≤ g",
" ↑f ⊓ 𝓟 sᶜᶜ = ⊥",
" sᶜ ∈ f ↔ s ∉ f"
] | [
" { toFilter := f, neBot' := h₁, le_of_le := h₂ } = { toFilter := g, neBot' := neBot'✝, le_of_le := le_of_le✝ }",
" (↑f ⊓ g).NeBot",
" Disjoint (↑f) g ↔ ¬↑f ≤ g",
" ↑f ⊓ 𝓟 sᶜᶜ = ⊥"
] |
import Mathlib.Data.List.Defs
import Mathlib.Data.Option.Basic
import Mathlib.Data.Nat.Defs
import Mathlib.Init.Data.List.Basic
import Mathlib.Util.AssertExists
-- Make sure we haven't imported `Data.Nat.Order.Basic`
assert_not_exists OrderedSub
namespace List
universe u v
variable {α : Type u} {β : Type v} (l :... | Mathlib/Data/List/GetD.lean | 102 | 105 | theorem getD_eq_getD_get? (n : ℕ) : l.getD n d = (l.get? n).getD d := by |
cases Nat.lt_or_ge n l.length with
| inl h => rw [getD_eq_get _ _ h, get?_eq_get h, Option.getD_some]
| inr h => rw [getD_eq_default _ _ h, get?_eq_none.mpr h, Option.getD_none]
| [
" l.getD n d = l.get ⟨n, hn⟩",
" [].getD n d = [].get ⟨n, hn⟩",
" (head :: tail).getD n d = (head :: tail).get ⟨n, hn⟩",
" (head :: tail).getD 0 d = (head :: tail).get ⟨0, hn⟩",
" (head :: tail).getD (n✝ + 1) d = (head :: tail).get ⟨n✝ + 1, hn⟩",
" (map f l).getD n (f d) = f (l.getD n d)",
" (map f []).... | [
" l.getD n d = l.get ⟨n, hn⟩",
" [].getD n d = [].get ⟨n, hn⟩",
" (head :: tail).getD n d = (head :: tail).get ⟨n, hn⟩",
" (head :: tail).getD 0 d = (head :: tail).get ⟨0, hn⟩",
" (head :: tail).getD (n✝ + 1) d = (head :: tail).get ⟨n✝ + 1, hn⟩",
" (map f l).getD n (f d) = f (l.getD n d)",
" (map f []).... |
import Mathlib.Analysis.InnerProductSpace.PiL2
import Mathlib.LinearAlgebra.Matrix.Block
#align_import analysis.inner_product_space.gram_schmidt_ortho from "leanprover-community/mathlib"@"1a4df69ca1a9a0e5e26bfe12e2b92814216016d0"
open Finset Submodule FiniteDimensional
variable (𝕜 : Type*) {E : Type*} [RCLike �... | Mathlib/Analysis/InnerProductSpace/GramSchmidtOrtho.lean | 83 | 108 | theorem gramSchmidt_orthogonal (f : ι → E) {a b : ι} (h₀ : a ≠ b) :
⟪gramSchmidt 𝕜 f a, gramSchmidt 𝕜 f b⟫ = 0 := by |
suffices ∀ a b : ι, a < b → ⟪gramSchmidt 𝕜 f a, gramSchmidt 𝕜 f b⟫ = 0 by
cases' h₀.lt_or_lt with ha hb
· exact this _ _ ha
· rw [inner_eq_zero_symm]
exact this _ _ hb
clear h₀ a b
intro a b h₀
revert a
apply wellFounded_lt.induction b
intro b ih a h₀
simp only [gramSchmidt_def 𝕜 f b... | [
" (invImage (fun x => x) IsWellOrder.toHasWellFounded).1 (↑i) n",
" gramSchmidt 𝕜 f n = f n - ∑ i ∈ Iio n, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i})) (f n))",
" f n = gramSchmidt 𝕜 f n + ∑ i ∈ Iio n, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i})) (f n))",
" f n = gramSchmidt 𝕜 f n + ∑... | [
" (invImage (fun x => x) IsWellOrder.toHasWellFounded).1 (↑i) n",
" gramSchmidt 𝕜 f n = f n - ∑ i ∈ Iio n, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i})) (f n))",
" f n = gramSchmidt 𝕜 f n + ∑ i ∈ Iio n, ↑((orthogonalProjection (span 𝕜 {gramSchmidt 𝕜 f i})) (f n))",
" f n = gramSchmidt 𝕜 f n + ∑... |
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 Inter
@[simp]
theorem inter_nil (l : L... | Mathlib/Data/List/Lattice.lean | 167 | 169 | theorem inter_eq_nil_iff_disjoint : l₁ ∩ l₂ = [] ↔ Disjoint l₁ l₂ := by |
simp only [eq_nil_iff_forall_not_mem, mem_inter_iff, not_and]
rfl
| [
" (a :: l₁) ∩ l₂ = a :: l₁ ∩ l₂",
" (a :: l₁) ∩ l₂ = l₁ ∩ l₂",
" a ∈ l₂",
" elem a l₂ = true",
" l₁ ∩ l₂ = [] ↔ l₁.Disjoint l₂",
" (∀ (a : α), a ∈ l₁ → ¬a ∈ l₂) ↔ l₁.Disjoint l₂"
] | [
" (a :: l₁) ∩ l₂ = a :: l₁ ∩ l₂",
" (a :: l₁) ∩ l₂ = l₁ ∩ l₂",
" a ∈ l₂",
" elem a l₂ = true"
] |
import Mathlib.AlgebraicGeometry.GammaSpecAdjunction
import Mathlib.AlgebraicGeometry.Restrict
import Mathlib.CategoryTheory.Limits.Opposites
import Mathlib.RingTheory.Localization.InvSubmonoid
#align_import algebraic_geometry.AffineScheme from "leanprover-community/mathlib"@"88474d1b5af6d37c2ab728b757771bced7f5194c"... | Mathlib/AlgebraicGeometry/AffineScheme.lean | 218 | 234 | theorem Scheme.map_PrimeSpectrum_basicOpen_of_affine
(X : Scheme) [IsAffine X] (f : Scheme.Γ.obj (op X)) :
X.isoSpec.hom ⁻¹ᵁ PrimeSpectrum.basicOpen f = X.basicOpen f := by |
rw [← basicOpen_eq_of_affine]
trans
X.isoSpec.hom ⁻¹ᵁ (Scheme.Spec.obj (op (Scheme.Γ.obj (op X)))).basicOpen
((inv (X.isoSpec.hom.1.c.app (op ((Opens.map (inv X.isoSpec.hom).val.base).obj ⊤)))) f)
· congr
rw [← IsIso.inv_eq_inv, IsIso.inv_inv, IsIso.Iso.inv_inv, NatIso.app_hom]
-- Porting not... | [
" IsAffine X",
" X ∈ Scheme.Spec.essImage",
" IsAffineOpen (Scheme.Hom.opensRange f)",
" Set.range ⇑f.val.base = Set.range ⇑(Y.ofRestrict ⋯).val.base",
" IsAffineOpen ⊤",
" ⊤ = Scheme.Hom.opensRange (𝟙 X)",
" ↑⊤ = ↑(Scheme.Hom.opensRange (𝟙 X))",
" Opens.IsBasis X.affineOpens",
" ∀ {U : Opens ↑↑X.... | [
" IsAffine X",
" X ∈ Scheme.Spec.essImage",
" IsAffineOpen (Scheme.Hom.opensRange f)",
" Set.range ⇑f.val.base = Set.range ⇑(Y.ofRestrict ⋯).val.base",
" IsAffineOpen ⊤",
" ⊤ = Scheme.Hom.opensRange (𝟙 X)",
" ↑⊤ = ↑(Scheme.Hom.opensRange (𝟙 X))",
" Opens.IsBasis X.affineOpens",
" ∀ {U : Opens ↑↑X.... |
import Mathlib.Probability.Variance
import Mathlib.MeasureTheory.Function.UniformIntegrable
#align_import probability.ident_distrib from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open MeasureTheory Filter Finset
noncomputable section
open scoped Topology MeasureTheory ENNReal NNR... | Mathlib/Probability/IdentDistrib.lean | 141 | 145 | theorem ae_snd (h : IdentDistrib f g μ ν) {p : γ → Prop} (pmeas : MeasurableSet {x | p x})
(hp : ∀ᵐ x ∂μ, p (f x)) : ∀ᵐ x ∂ν, p (g x) := by |
apply (ae_map_iff h.aemeasurable_snd pmeas).1
rw [← h.map_eq]
exact (ae_map_iff h.aemeasurable_fst pmeas).2 hp
| [
" AEMeasurable (u ∘ g) ν",
" Measure.map (u ∘ f) μ = Measure.map (u ∘ g) ν",
" AEMeasurable u (Measure.map g ν)",
" μ (f ⁻¹' s) = ν (g ⁻¹' s)",
" ∀ᵐ (x : β) ∂ν, p (g x)",
" ∀ᵐ (y : γ) ∂Measure.map g ν, p y",
" ∀ᵐ (y : γ) ∂Measure.map f μ, p y"
] | [
" AEMeasurable (u ∘ g) ν",
" Measure.map (u ∘ f) μ = Measure.map (u ∘ g) ν",
" AEMeasurable u (Measure.map g ν)",
" μ (f ⁻¹' s) = ν (g ⁻¹' s)"
] |
import Mathlib.FieldTheory.Finite.Basic
#align_import field_theory.chevalley_warning from "leanprover-community/mathlib"@"e001509c11c4d0f549d91d89da95b4a0b43c714f"
universe u v
section FiniteField
open MvPolynomial
open Function hiding eval
open Finset FiniteField
variable {K σ ι : Type*} [Fintype K] [Field ... | Mathlib/FieldTheory/ChevalleyWarning.lean | 53 | 97 | theorem MvPolynomial.sum_eval_eq_zero (f : MvPolynomial σ K)
(h : f.totalDegree < (q - 1) * Fintype.card σ) : ∑ x, eval x f = 0 := by |
haveI : DecidableEq K := Classical.decEq K
calc
∑ x, eval x f = ∑ x : σ → K, ∑ d ∈ f.support, f.coeff d * ∏ i, x i ^ d i := by
simp only [eval_eq']
_ = ∑ d ∈ f.support, ∑ x : σ → K, f.coeff d * ∏ i, x i ^ d i := sum_comm
_ = 0 := sum_eq_zero ?_
intro d hd
obtain ⟨i, hi⟩ : ∃ i, d i < q - 1 := ... | [
" ∑ x : σ → K, (eval x) f = 0",
" ∑ x : σ → K, (eval x) f = ∑ x : σ → K, ∑ d ∈ f.support, coeff d f * ∏ i : σ, x i ^ d i",
" ∀ x ∈ f.support, ∑ x_1 : σ → K, coeff x f * ∏ i : σ, x_1 i ^ x i = 0",
" ∑ x : σ → K, coeff d f * ∏ i : σ, x i ^ d i = 0",
" ∑ x : σ → K, ∏ i : σ, x i ^ d i = 0",
" ∀ (a : { j // j ... | [] |
import Mathlib.MeasureTheory.Function.L1Space
import Mathlib.MeasureTheory.Function.SimpleFuncDense
#align_import measure_theory.function.simple_func_dense_lp from "leanprover-community/mathlib"@"5a2df4cd59cb31e97a516d4603a14bed5c2f9425"
noncomputable section
set_option linter.uppercaseLean3 false
open Set Func... | Mathlib/MeasureTheory/Function/SimpleFuncDenseLp.lean | 68 | 74 | theorem nnnorm_approxOn_le [OpensMeasurableSpace E] {f : β → E} (hf : Measurable f) {s : Set E}
{y₀ : E} (h₀ : y₀ ∈ s) [SeparableSpace s] (x : β) (n : ℕ) :
‖approxOn f hf s y₀ h₀ n x - f x‖₊ ≤ ‖f x - y₀‖₊ := by |
have := edist_approxOn_le hf h₀ x n
rw [edist_comm y₀] at this
simp only [edist_nndist, nndist_eq_nnnorm] at this
exact mod_cast this
| [
" ‖↑(approxOn f hf s y₀ h₀ n) x - f x‖₊ ≤ ‖f x - y₀‖₊"
] | [] |
import Mathlib.AlgebraicTopology.SimplexCategory
import Mathlib.CategoryTheory.Comma.Arrow
import Mathlib.CategoryTheory.Limits.FunctorCategory
import Mathlib.CategoryTheory.Opposites
#align_import algebraic_topology.simplicial_object from "leanprover-community/mathlib"@"5ed51dc37c6b891b79314ee11a50adc2b1df6fd6"
o... | Mathlib/AlgebraicTopology/SimplicialObject.lean | 146 | 149 | theorem δ_comp_σ_of_le {n} {i : Fin (n + 2)} {j : Fin (n + 1)} (H : i ≤ Fin.castSucc j) :
X.σ j.succ ≫ X.δ (Fin.castSucc i) = X.δ i ≫ X.σ j := by |
dsimp [δ, σ]
simp only [← X.map_comp, ← op_comp, SimplexCategory.δ_comp_σ_of_le H]
| [
" Category.{?u.61, max u v} (SimplicialObject C)",
" Category.{?u.61, max u v} (SimplexCategoryᵒᵖ ⥤ C)",
" HasLimitsOfShape J (SimplicialObject C)",
" HasLimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)",
" HasColimitsOfShape J (SimplicialObject C)",
" HasColimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)",
" f.app = g.a... | [
" Category.{?u.61, max u v} (SimplicialObject C)",
" Category.{?u.61, max u v} (SimplexCategoryᵒᵖ ⥤ C)",
" HasLimitsOfShape J (SimplicialObject C)",
" HasLimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)",
" HasColimitsOfShape J (SimplicialObject C)",
" HasColimitsOfShape J (SimplexCategoryᵒᵖ ⥤ C)",
" f.app = g.a... |
import Mathlib.Data.Set.Lattice
import Mathlib.Init.Set
import Mathlib.Control.Basic
import Mathlib.Lean.Expr.ExtraRecognizers
#align_import data.set.functor from "leanprover-community/mathlib"@"207cfac9fcd06138865b5d04f7091e46d9320432"
universe u
open Function
namespace Set
variable {α β : Type u} {s : Set α} ... | Mathlib/Data/Set/Functor.lean | 155 | 156 | theorem image_image_val_eq_restrict_image {δ : Type*} {f : α → δ} : f '' γ = β.restrict f '' γ := by |
ext; simp
| [
" Lean.Internal.coeM t = Subtype.val '' t",
" ⋃ x ∈ t, {↑x} = Subtype.val '' t",
" x✝ ∈ ⋃ x ∈ t, {↑x} ↔ x✝ ∈ Subtype.val '' t",
" Subtype.val '' γ ⊆ β",
" ↑⟨val✝, ha⟩ ∈ β",
" ⟨a, ⋯⟩ ∈ γ",
" ⟨↑w✝, ⋯⟩ ∈ γ",
" f '' (Subtype.val '' γ) = β.restrict f '' γ",
" x✝ ∈ f '' (Subtype.val '' γ) ↔ x✝ ∈ β.restric... | [
" Lean.Internal.coeM t = Subtype.val '' t",
" ⋃ x ∈ t, {↑x} = Subtype.val '' t",
" x✝ ∈ ⋃ x ∈ t, {↑x} ↔ x✝ ∈ Subtype.val '' t",
" Subtype.val '' γ ⊆ β",
" ↑⟨val✝, ha⟩ ∈ β",
" ⟨a, ⋯⟩ ∈ γ",
" ⟨↑w✝, ⋯⟩ ∈ γ"
] |
import Mathlib.Geometry.Euclidean.Sphere.Basic
import Mathlib.LinearAlgebra.AffineSpace.FiniteDimensional
import Mathlib.Tactic.DeriveFintype
#align_import geometry.euclidean.circumcenter from "leanprover-community/mathlib"@"2de9c37fa71dde2f1c6feff19876dd6a7b1519f0"
noncomputable section
open scoped Classical
o... | Mathlib/Geometry/Euclidean/Circumcenter.lean | 48 | 56 | theorem dist_eq_iff_dist_orthogonalProjection_eq {s : AffineSubspace ℝ P} [Nonempty s]
[HasOrthogonalProjection s.direction] {p1 p2 : P} (p3 : P) (hp1 : p1 ∈ s) (hp2 : p2 ∈ s) :
dist p1 p3 = dist p2 p3 ↔
dist p1 (orthogonalProjection s p3) = dist p2 (orthogonalProjection s p3) := by |
rw [← mul_self_inj_of_nonneg dist_nonneg dist_nonneg, ←
mul_self_inj_of_nonneg dist_nonneg dist_nonneg,
dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p3 hp1,
dist_sq_eq_dist_orthogonalProjection_sq_add_dist_orthogonalProjection_sq p3 hp2]
simp
| [
" dist p1 p3 = dist p2 p3 ↔ dist p1 ↑((orthogonalProjection s) p3) = dist p2 ↑((orthogonalProjection s) p3)",
" dist p1 ↑((orthogonalProjection s) p3) * dist p1 ↑((orthogonalProjection s) p3) +\n dist p3 ↑((orthogonalProjection s) p3) * dist p3 ↑((orthogonalProjection s) p3) =\n dist p2 ↑((orthogonalP... | [] |
import Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.measure.haar.normed_space from "leanprover-community/mathlib"@"b84aee748341da06a6d78491367e2c0e9f15e8a5"
noncomputable sect... | Mathlib/MeasureTheory/Measure/Haar/NormedSpace.lean | 64 | 83 | theorem integral_comp_smul (f : E → F) (R : ℝ) :
∫ x, f (R • x) ∂μ = |(R ^ finrank ℝ E)⁻¹| • ∫ x, f x ∂μ := by |
by_cases hF : CompleteSpace F; swap
· simp [integral, hF]
rcases eq_or_ne R 0 with (rfl | hR)
· simp only [zero_smul, integral_const]
rcases Nat.eq_zero_or_pos (finrank ℝ E) with (hE | hE)
· have : Subsingleton E := finrank_zero_iff.1 hE
have : f = fun _ => f 0 := by ext x; rw [Subsingleton.elim ... | [
" NoAtoms μ",
" ∫ (x : E), f (R • x) ∂μ = |(R ^ finrank ℝ E)⁻¹| • ∫ (x : E), f x ∂μ",
" ∫ (x : E), f (0 • x) ∂μ = |(0 ^ finrank ℝ E)⁻¹| • ∫ (x : E), f x ∂μ",
" (μ univ).toReal • f 0 = |(0 ^ finrank ℝ E)⁻¹| • ∫ (x : E), f x ∂μ",
" f = fun x => f 0",
" f x = f 0",
"E : Type u_1\ninst✝⁷ : NormedAddCommGrou... | [
" NoAtoms μ"
] |
import Mathlib.Analysis.NormedSpace.PiLp
import Mathlib.Analysis.InnerProductSpace.PiL2
#align_import analysis.matrix from "leanprover-community/mathlib"@"46b633fd842bef9469441c0209906f6dddd2b4f5"
noncomputable section
open scoped NNReal Matrix
namespace Matrix
variable {R l m n α β : Type*} [Fintype l] [Fintyp... | Mathlib/Analysis/Matrix.lean | 98 | 99 | theorem norm_lt_iff {r : ℝ} (hr : 0 < r) {A : Matrix m n α} : ‖A‖ < r ↔ ∀ i j, ‖A i j‖ < r := by |
simp_rw [norm_def, pi_norm_lt_iff hr]
| [
" ‖A‖ = ↑(Finset.univ.sup fun i => Finset.univ.sup fun j => ‖A i j‖₊)",
" ‖A‖ ≤ r ↔ ∀ (i : m) (j : n), ‖A i j‖ ≤ r",
" ‖A‖₊ ≤ r ↔ ∀ (i : m) (j : n), ‖A i j‖₊ ≤ r",
" ‖A‖ < r ↔ ∀ (i : m) (j : n), ‖A i j‖ < r"
] | [
" ‖A‖ = ↑(Finset.univ.sup fun i => Finset.univ.sup fun j => ‖A i j‖₊)",
" ‖A‖ ≤ r ↔ ∀ (i : m) (j : n), ‖A i j‖ ≤ r",
" ‖A‖₊ ≤ r ↔ ∀ (i : m) (j : n), ‖A i j‖₊ ≤ r"
] |
import Mathlib.Analysis.Calculus.FDeriv.Equiv
import Mathlib.Analysis.Calculus.FormalMultilinearSeries
#align_import analysis.calculus.cont_diff_def from "leanprover-community/mathlib"@"3a69562db5a458db8322b190ec8d9a8bbd8a5b14"
noncomputable section
open scoped Classical
open NNReal Topology Filter
local notatio... | Mathlib/Analysis/Calculus/ContDiff/Defs.lean | 229 | 237 | theorem hasFTaylorSeriesUpToOn_zero_iff :
HasFTaylorSeriesUpToOn 0 f p s ↔ ContinuousOn f s ∧ ∀ x ∈ s, (p x 0).uncurry0 = f x := by |
refine ⟨fun H => ⟨H.continuousOn, H.zero_eq⟩, fun H =>
⟨H.2, fun m hm => False.elim (not_le.2 hm bot_le), fun m hm ↦ ?_⟩⟩
obtain rfl : m = 0 := mod_cast hm.antisymm (zero_le _)
have : EqOn (p · 0) ((continuousMultilinearCurryFin0 𝕜 E F).symm ∘ f) s := fun x hx ↦
(continuousMultilinearCurryFin0 𝕜 E F)... | [
" p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (f x)",
" p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0",
" HasFTaylorSeriesUpToOn n f₁ p s",
" (p x 0).uncurry0 = f₁ x",
" (p x 0).uncurry0 = f x",
" ContinuousOn f s",
" HasFTaylorSeriesUpToOn 0 f p s ↔ ContinuousOn f s ∧ ∀... | [
" p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (f x)",
" p x 0 = (continuousMultilinearCurryFin0 𝕜 E F).symm (p x 0).uncurry0",
" HasFTaylorSeriesUpToOn n f₁ p s",
" (p x 0).uncurry0 = f₁ x",
" (p x 0).uncurry0 = f x",
" ContinuousOn f s"
] |
import Mathlib.CategoryTheory.Limits.Shapes.Images
import Mathlib.CategoryTheory.Limits.Constructions.EpiMono
#align_import category_theory.limits.preserves.shapes.images from "leanprover-community/mathlib"@"fc78e3c190c72a109699385da6be2725e88df841"
noncomputable section
namespace CategoryTheory
namespace Prese... | Mathlib/CategoryTheory/Limits/Preserves/Shapes/Images.lean | 57 | 58 | theorem hom_comp_map_image_ι {X Y : A} (f : X ⟶ Y) :
(iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f) := by | rw [iso_hom, image.lift_fac]
| [
" L.map (factorThruImage f) ≫ L.map (image.ι f) = L.map f",
" factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f)",
" (iso L f).hom ≫ L.map (image.ι f) = image.ι (L.map f)"
] | [
" L.map (factorThruImage f) ≫ L.map (image.ι f) = L.map f",
" factorThruImage (L.map f) ≫ (iso L f).hom = L.map (factorThruImage f)"
] |
import Mathlib.Analysis.Complex.CauchyIntegral
import Mathlib.Analysis.Calculus.FDeriv.Analytic
import Mathlib.Analysis.NormedSpace.Completion
#align_import analysis.complex.liouville from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open TopologicalSpace Metric Set Filter Asymptotics ... | Mathlib/Analysis/Complex/Liouville.lean | 71 | 84 | theorem norm_deriv_le_of_forall_mem_sphere_norm_le {c : ℂ} {R C : ℝ} {f : ℂ → F} (hR : 0 < R)
(hd : DiffContOnCl ℂ f (ball c R)) (hC : ∀ z ∈ sphere c R, ‖f z‖ ≤ C) :
‖deriv f c‖ ≤ C / R := by |
set e : F →L[ℂ] F̂ := UniformSpace.Completion.toComplL
have : HasDerivAt (e ∘ f) (e (deriv f c)) c :=
e.hasFDerivAt.comp_hasDerivAt c
(hd.differentiableAt isOpen_ball <| mem_ball_self hR).hasDerivAt
calc
‖deriv f c‖ = ‖deriv (e ∘ f) c‖ := by
rw [this.deriv]
exact (UniformSpace.Completio... | [
" deriv f c = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - c) ^ (-2) • f z",
" deriv f c = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, ↑R), (z - c) ^ (-2) • f z",
" ((cauchyPowerSeries f c (↑R) 1) fun x => 1) = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, ↑R), (z - c) ^ (-2) • f z",
" ‖deriv f c‖ ≤ C / R",
" ‖(z - c) ^ (-2) • ... | [
" deriv f c = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, R), (z - c) ^ (-2) • f z",
" deriv f c = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, ↑R), (z - c) ^ (-2) • f z",
" ((cauchyPowerSeries f c (↑R) 1) fun x => 1) = (2 * ↑π * I)⁻¹ • ∮ (z : ℂ) in C(c, ↑R), (z - c) ^ (-2) • f z",
" ‖deriv f c‖ ≤ C / R",
" ‖(z - c) ^ (-2) • ... |
import Mathlib.Algebra.Order.Ring.Abs
#align_import data.int.order.lemmas from "leanprover-community/mathlib"@"fc2ed6f838ce7c9b7c7171e58d78eaf7b438fb0e"
open Function Nat
namespace Int
variable {a b : ℤ} {n : ℕ}
theorem natAbs_eq_iff_mul_self_eq {a b : ℤ} : a.natAbs = b.natAbs ↔ a * a = b * b := by
rw [← a... | Mathlib/Data/Int/Order/Lemmas.lean | 40 | 42 | theorem natAbs_le_iff_mul_self_le {a b : ℤ} : a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b := by |
rw [← abs_le_iff_mul_self_le, abs_eq_natAbs, abs_eq_natAbs]
exact Int.ofNat_le.symm
| [
" a.natAbs = b.natAbs ↔ a * a = b * b",
" a.natAbs = b.natAbs ↔ ↑a.natAbs = ↑b.natAbs",
" a.natAbs < b.natAbs ↔ a * a < b * b",
" a.natAbs < b.natAbs ↔ ↑a.natAbs < ↑b.natAbs",
" a.natAbs ≤ b.natAbs ↔ a * a ≤ b * b",
" a.natAbs ≤ b.natAbs ↔ ↑a.natAbs ≤ ↑b.natAbs"
] | [
" a.natAbs = b.natAbs ↔ a * a = b * b",
" a.natAbs = b.natAbs ↔ ↑a.natAbs = ↑b.natAbs",
" a.natAbs < b.natAbs ↔ a * a < b * b",
" a.natAbs < b.natAbs ↔ ↑a.natAbs < ↑b.natAbs"
] |
import Mathlib.Control.Bitraversable.Basic
#align_import control.bitraversable.lemmas from "leanprover-community/mathlib"@"58581d0fe523063f5651df0619be2bf65012a94a"
universe u
variable {t : Type u → Type u → Type u} [Bitraversable t]
variable {β : Type u}
namespace Bitraversable
open Functor LawfulApplicative
... | Mathlib/Control/Bitraversable/Lemmas.lean | 95 | 99 | theorem comp_tsnd {α β₀ β₁ β₂} (g : β₀ → F β₁) (g' : β₁ → G β₂) (x : t α β₀) :
Comp.mk (tsnd g' <$> tsnd g x) = tsnd (Comp.mk ∘ map g' ∘ g) x := by |
rw [← comp_bitraverse]
simp only [Function.comp, map_pure]
rfl
| [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... | [
" Comp.mk (tfst f' <$> tfst f x) = tfst (Comp.mk ∘ map f' ∘ f) x",
" bitraverse (Comp.mk ∘ map f' ∘ f) (Comp.mk ∘ map pure ∘ pure) x = tfst (Comp.mk ∘ map f' ∘ f) x",
" Comp.mk (tfst f <$> tsnd f' x) = bitraverse (Comp.mk ∘ pure ∘ f) (Comp.mk ∘ map pure ∘ f') x",
" bitraverse (Comp.mk ∘ map f ∘ pure) (Comp.mk... |
import Mathlib.Analysis.Calculus.FDeriv.Bilinear
#align_import analysis.calculus.fderiv.mul from "leanprover-community/mathlib"@"d608fc5d4e69d4cc21885913fb573a88b0deb521"
open scoped Classical
open Filter Asymptotics ContinuousLinearMap Set Metric Topology NNReal ENNReal
noncomputable section
section
variable ... | Mathlib/Analysis/Calculus/FDeriv/Mul.lean | 391 | 395 | theorem HasFDerivWithinAt.mul (hc : HasFDerivWithinAt c c' s x) (hd : HasFDerivWithinAt d d' s x) :
HasFDerivWithinAt (fun y => c y * d y) (c x • d' + d x • c') s x := by |
convert hc.mul' hd
ext z
apply mul_comm
| [
" HasStrictFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x",
" d x • c' = c'.smulRight (d x)",
" (d x • c') z = (c'.smulRight (d x)) z",
" HasFDerivWithinAt (fun y => c y * d y) (c x • d' + d x • c') s x"
] | [
" HasStrictFDerivAt (fun y => c y * d y) (c x • d' + d x • c') x",
" d x • c' = c'.smulRight (d x)",
" (d x • c') z = (c'.smulRight (d x)) z"
] |
import Mathlib.Algebra.EuclideanDomain.Defs
import Mathlib.Algebra.Ring.Divisibility.Basic
import Mathlib.Algebra.Ring.Regular
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Ring.Basic
#align_import algebra.euclidean_domain.basic from "leanprover-community/mathlib"@"bf9bbbcf0c1c1ead18280b0d0... | Mathlib/Algebra/EuclideanDomain/Basic.lean | 96 | 101 | theorem mul_div_assoc (x : R) {y z : R} (h : z ∣ y) : x * y / z = x * (y / z) := by |
by_cases hz : z = 0
· subst hz
rw [div_zero, div_zero, mul_zero]
rcases h with ⟨p, rfl⟩
rw [mul_div_cancel_left₀ _ hz, mul_left_comm, mul_div_cancel_left₀ _ hz]
| [
" a * b / b = a",
" a - a * b / b = 0",
" False",
" b ∣ a",
" b ∣ b * (a / b)",
" a % b = 0",
" b * c = b * (b * c / b)",
" c ∣ a % b ↔ c ∣ a",
" 0 / a = 0",
" a / a = 1",
" a = c / b",
" b = c / a",
" x * y / z = x * (y / z)",
" x * y / 0 = x * (y / 0)",
" x * (z * p) / z = x * (z * p /... | [
" a * b / b = a",
" a - a * b / b = 0",
" False",
" b ∣ a",
" b ∣ b * (a / b)",
" a % b = 0",
" b * c = b * (b * c / b)",
" c ∣ a % b ↔ c ∣ a",
" 0 / a = 0",
" a / a = 1",
" a = c / b",
" b = c / a"
] |
import Mathlib.Analysis.Convex.Topology
import Mathlib.LinearAlgebra.Dimension.DivisionRing
import Mathlib.Topology.Algebra.Module.Cardinality
open Convex Set Metric
section TopologicalVectorSpace
variable {E : Type*} [AddCommGroup E] [Module ℝ E]
[TopologicalSpace E] [ContinuousAdd E] [ContinuousSMul ℝ E]
| Mathlib/Analysis/NormedSpace/Connected.lean | 34 | 103 | theorem Set.Countable.isPathConnected_compl_of_one_lt_rank
(h : 1 < Module.rank ℝ E) {s : Set E} (hs : s.Countable) :
IsPathConnected sᶜ := by |
have : Nontrivial E := (rank_pos_iff_nontrivial (R := ℝ)).1 (zero_lt_one.trans h)
-- the set `sᶜ` is dense, therefore nonempty. Pick `a ∈ sᶜ`. We have to show that any
-- `b ∈ sᶜ` can be joined to `a`.
obtain ⟨a, ha⟩ : sᶜ.Nonempty := (hs.dense_compl ℝ).nonempty
refine ⟨a, ha, ?_⟩
intro b hb
rcases eq_or_... | [
" IsPathConnected sᶜ",
" ∀ {y : E}, y ∈ sᶜ → JoinedIn sᶜ a y",
" JoinedIn sᶜ a b",
" JoinedIn sᶜ a a",
" c - x = a",
" 2⁻¹ • a + 2⁻¹ • b - (2⁻¹ • b - 2⁻¹ • a) = a",
" 2 • 2⁻¹ • a = a",
" c + x = b",
" 2⁻¹ • a + 2⁻¹ • b + (2⁻¹ • b - 2⁻¹ • a) = b",
" 2 • 2⁻¹ • b = b",
" x ≠ 0",
" {t | ([c + x-[ℝ... | [] |
import Mathlib.Order.PartialSups
#align_import order.disjointed from "leanprover-community/mathlib"@"f7fc89d5d5ff1db2d1242c7bb0e9062ce47ef47c"
variable {α β : Type*}
section GeneralizedBooleanAlgebra
variable [GeneralizedBooleanAlgebra α]
def disjointed (f : ℕ → α) : ℕ → α
| 0 => f 0
| n + 1 => f (n + 1) ... | Mathlib/Order/Disjointed.lean | 123 | 136 | theorem disjointed_unique {f d : ℕ → α} (hdisj : Pairwise (Disjoint on d))
(hsups : partialSups d = partialSups f) : d = disjointed f := by |
ext n
cases' n with n
· rw [← partialSups_zero d, hsups, partialSups_zero, disjointed_zero]
suffices h : d n.succ = partialSups d n.succ \ partialSups d n by
rw [h, hsups, partialSups_succ, disjointed_succ, sup_sdiff, sdiff_self, bot_sup_eq]
rw [partialSups_succ, sup_sdiff, sdiff_self, bot_sup_eq, eq_com... | [
" disjointed ≤ id",
" disjointed f n ≤ id f n",
" disjointed f 0 ≤ id f 0",
" disjointed f (n✝ + 1) ≤ id f (n✝ + 1)",
" Pairwise (Disjoint on disjointed f)",
" Disjoint (disjointed f m) (disjointed f n)",
" Disjoint (disjointed f m) (disjointed f 0)",
" Disjoint (disjointed f m) (disjointed f (n✝ + 1)... | [
" disjointed ≤ id",
" disjointed f n ≤ id f n",
" disjointed f 0 ≤ id f 0",
" disjointed f (n✝ + 1) ≤ id f (n✝ + 1)",
" Pairwise (Disjoint on disjointed f)",
" Disjoint (disjointed f m) (disjointed f n)",
" Disjoint (disjointed f m) (disjointed f 0)",
" Disjoint (disjointed f m) (disjointed f (n✝ + 1)... |
import Mathlib.MeasureTheory.Covering.Differentiation
import Mathlib.MeasureTheory.Covering.VitaliFamily
import Mathlib.MeasureTheory.Integral.Lebesgue
import Mathlib.MeasureTheory.Measure.Regular
import Mathlib.SetTheory.Ordinal.Arithmetic
import Mathlib.Topology.MetricSpace.Basic
import Mathlib.Data.Set.Pairwise.Lat... | Mathlib/MeasureTheory/Covering/Besicovitch.lean | 278 | 281 | theorem monotone_iUnionUpTo : Monotone p.iUnionUpTo := by |
intro i j hij
simp only [iUnionUpTo]
exact iUnion_mono' fun r => ⟨⟨r, r.2.trans_le hij⟩, Subset.rfl⟩
| [
" (fun x => 1) i ≤ dist (default i) (default (last 0)) ∧ (fun x => 1) (last 0) ≤ τ * (fun x => 1) i",
" dist (default i) (default (last 0)) ≤ (fun x => 1) i + (fun x => 1) (last 0)",
" (invImage (fun x => x) Ordinal.wellFoundedRelation).1 (↑j) a✝",
" Monotone p.iUnionUpTo",
" p.iUnionUpTo i ≤ p.iUnionUpTo j... | [
" (fun x => 1) i ≤ dist (default i) (default (last 0)) ∧ (fun x => 1) (last 0) ≤ τ * (fun x => 1) i",
" dist (default i) (default (last 0)) ≤ (fun x => 1) i + (fun x => 1) (last 0)",
" (invImage (fun x => x) Ordinal.wellFoundedRelation).1 (↑j) a✝"
] |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.ConditionallyCompleteLattice.Basic
#align_import order.filter.lift from "leanprover-community/mathlib"@"8631e2d5ea77f6c13054d9151d82b83069680cb1"
open Set Classical Filter Function
namespace Filter
variable {α β γ : Type*} {ι : Sort*}
section lift
protect... | Mathlib/Order/Filter/Lift.lean | 117 | 118 | theorem comap_lift_eq {m : γ → β} : comap m (f.lift g) = f.lift (comap m ∘ g) := by |
simp only [Filter.lift, comap_iInf]; rfl
| [
" ⊤.lift g = g univ",
" s ∈ f.lift g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s",
" DirectedOn ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) f.sets",
" ∃ z ∈ f.sets, ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₁ z ∧ ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₂ z",
" (∃ i ∈ f.sets, s ∈ g i) ↔ ∃ i, p i ∧ ∃ x, pg i x... | [
" ⊤.lift g = g univ",
" s ∈ f.lift g ↔ ∃ i, p i ∧ ∃ x, pg i x ∧ sg i x ⊆ s",
" DirectedOn ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) f.sets",
" ∃ z ∈ f.sets, ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₁ z ∧ ((fun s => g s) ⁻¹'o fun x x_1 => x ≥ x_1) t₂ z",
" (∃ i ∈ f.sets, s ∈ g i) ↔ ∃ i, p i ∧ ∃ x, pg i x... |
import Mathlib.ModelTheory.Satisfiability
#align_import model_theory.types from "leanprover-community/mathlib"@"98bd247d933fb581ff37244a5998bd33d81dd46d"
set_option linter.uppercaseLean3 false
universe u v w w'
open Cardinal Set
open scoped Classical
open Cardinal FirstOrder
namespace FirstOrder
namespace La... | Mathlib/ModelTheory/Types.lean | 147 | 151 | theorem nonempty_iff : Nonempty (T.CompleteType α) ↔ T.IsSatisfiable := by |
rw [← isSatisfiable_onTheory_iff (lhomWithConstants_injective L α)]
rw [nonempty_iff_univ_nonempty, nonempty_iff_ne_empty, Ne, not_iff_comm,
← union_empty ((L.lhomWithConstants α).onTheory T), ← setOf_subset_eq_empty_iff]
simp
| [
" p = q",
" { toTheory := toTheory✝, subset' := subset'✝, isMaximal' := isMaximal'✝ } = q",
" { toTheory := toTheory✝¹, subset' := subset'✝¹, isMaximal' := isMaximal'✝¹ } =\n { toTheory := toTheory✝, subset' := subset'✝, isMaximal' := isMaximal'✝ }",
" False",
" ¬{φ, Formula.not φ}.IsSatisfiable",
" {φ... | [
" p = q",
" { toTheory := toTheory✝, subset' := subset'✝, isMaximal' := isMaximal'✝ } = q",
" { toTheory := toTheory✝¹, subset' := subset'✝¹, isMaximal' := isMaximal'✝¹ } =\n { toTheory := toTheory✝, subset' := subset'✝, isMaximal' := isMaximal'✝ }",
" False",
" ¬{φ, Formula.not φ}.IsSatisfiable",
" {φ... |
import Mathlib.Data.Finsupp.Encodable
import Mathlib.LinearAlgebra.Pi
import Mathlib.LinearAlgebra.Span
import Mathlib.Data.Set.Countable
#align_import linear_algebra.finsupp from "leanprover-community/mathlib"@"9d684a893c52e1d6692a504a118bfccbae04feeb"
noncomputable section
open Set LinearMap Submodule
namespa... | Mathlib/LinearAlgebra/Finsupp.lean | 260 | 263 | theorem iSup_lsingle_range : ⨆ a, LinearMap.range (lsingle a : M →ₗ[R] α →₀ M) = ⊤ := by |
refine eq_top_iff.2 <| SetLike.le_def.2 fun f _ => ?_
rw [← sum_single f]
exact sum_mem fun a _ => Submodule.mem_iSup_of_mem a ⟨_, rfl⟩
| [
" ⇑(x + y) = ⇑x + ⇑y",
" (x + y) x✝ = (⇑x + ⇑y) x✝",
" { toFun := DFunLike.coe, map_add' := ⋯ }.toFun (x • y) =\n (RingHom.id R) x • { toFun := DFunLike.coe, map_add' := ⋯ }.toFun y",
" { toFun := DFunLike.coe, map_add' := ⋯ }.toFun (x • y) x✝ =\n ((RingHom.id R) x • { toFun := DFunLike.coe, map_add' :=... | [
" ⇑(x + y) = ⇑x + ⇑y",
" (x + y) x✝ = (⇑x + ⇑y) x✝",
" { toFun := DFunLike.coe, map_add' := ⋯ }.toFun (x • y) =\n (RingHom.id R) x • { toFun := DFunLike.coe, map_add' := ⋯ }.toFun y",
" { toFun := DFunLike.coe, map_add' := ⋯ }.toFun (x • y) x✝ =\n ((RingHom.id R) x • { toFun := DFunLike.coe, map_add' :=... |
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.LinearAlgebra.Determinant
import Mathlib.LinearAlgebra.Matrix.Diagonal
import Mathlib.LinearAlgebra.Matrix.Transvection
import Mathlib.MeasureTheory.Group.LIntegral
import Mathlib.MeasureTheory.Integral.Marginal
import Mathlib.MeasureTheory.Measure.Stiel... | Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean | 624 | 653 | theorem ae_restrict_of_ae_restrict_inter_Ioo {μ : Measure ℝ} [NoAtoms μ] {s : Set ℝ} {p : ℝ → Prop}
(h : ∀ a b, a ∈ s → b ∈ s → a < b → ∀ᵐ x ∂μ.restrict (s ∩ Ioo a b), p x) :
∀ᵐ x ∂μ.restrict s, p x := by |
/- By second-countability, we cover `s` by countably many intervals `(a, b)` (except maybe for
two endpoints, which don't matter since `μ` does not have any atom). -/
let T : s × s → Set ℝ := fun p => Ioo p.1 p.2
let u := ⋃ i : ↥s × ↥s, T i
have hfinite : (s \ u).Finite := s.finite_diff_iUnion_Ioo'
obtai... | [
" ∀ᵐ (x : ℝ) ∂μ.restrict s, p x",
" s ⊆ s \\ u ∪ ⋃ p ∈ A, s ∩ T p",
" x ∈ s \\ u ∪ ⋃ p ∈ A, s ∩ T p",
" ∃ p ∈ A, x ∈ T p",
" x ∈ ⋃ p ∈ A, s ∩ T p",
" ∀ᵐ (x : ℝ) ∂μ.restrict (s \\ u ∪ ⋃ p ∈ A, s ∩ T p), p x",
" (∀ᵐ (x : ℝ) ∂μ.restrict (s \\ u), p x) ∧ ∀ i ∈ A, ∀ᵐ (x : ℝ) ∂μ.restrict (s ∩ T i), p x",
" ... | [] |
import Mathlib.Data.Fintype.Quotient
import Mathlib.ModelTheory.Semantics
#align_import model_theory.quotients from "leanprover-community/mathlib"@"d78597269638367c3863d40d45108f52207e03cf"
namespace FirstOrder
namespace Language
variable (L : Language) {M : Type*}
open FirstOrder
open Structure
class Prest... | Mathlib/ModelTheory/Quotients.lean | 57 | 62 | theorem funMap_quotient_mk' {n : ℕ} (f : L.Functions n) (x : Fin n → M) :
(funMap f fun i => (⟦x i⟧ : Quotient s)) = ⟦@funMap _ _ ps.toStructure _ f x⟧ := by |
change
Quotient.map (@funMap L M ps.toStructure n f) Prestructure.fun_equiv (Quotient.finChoice _) =
_
rw [Quotient.finChoice_eq, Quotient.map_mk]
| [
" (funMap f fun i => ⟦x i⟧) = ⟦funMap f x⟧",
" Quotient.map (funMap f) ⋯ (Quotient.finChoice fun i => ⟦x i⟧) = ⟦funMap f x⟧"
] | [] |
import Mathlib.LinearAlgebra.Dimension.StrongRankCondition
import Mathlib.LinearAlgebra.FreeModule.Basic
import Mathlib.LinearAlgebra.FreeModule.Finite.Basic
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomputable section
universe u v v'... | Mathlib/LinearAlgebra/Dimension/Free.lean | 41 | 48 | theorem lift_rank_mul_lift_rank :
Cardinal.lift.{w} (Module.rank F K) * Cardinal.lift.{v} (Module.rank K A) =
Cardinal.lift.{v} (Module.rank F A) := by |
let b := Module.Free.chooseBasis F K
let c := Module.Free.chooseBasis K A
rw [← (Module.rank F K).lift_id, ← b.mk_eq_rank, ← (Module.rank K A).lift_id, ← c.mk_eq_rank,
← lift_umax.{w, v}, ← (b.smul c).mk_eq_rank, mk_prod, lift_mul, lift_lift, lift_lift, lift_lift,
lift_lift, lift_umax.{v, w}]
| [
" lift.{w, v} (Module.rank F K) * lift.{v, w} (Module.rank K A) = lift.{v, w} (Module.rank F A)"
] | [] |
import Mathlib.ModelTheory.Basic
#align_import model_theory.language_map from "leanprover-community/mathlib"@"b3951c65c6e797ff162ae8b69eab0063bcfb3d73"
universe u v u' v' w w'
namespace FirstOrder
set_option linter.uppercaseLean3 false
namespace Language
open Structure Cardinal
open Cardinal
variable (L : L... | Mathlib/ModelTheory/LanguageMap.lean | 159 | 161 | theorem comp_id (F : L →ᴸ L') : F ∘ᴸ LHom.id L = F := by |
cases F
rfl
| [
" F = G",
" { onFunction := Ff, onRelation := Fr } = G",
" { onFunction := Ff, onRelation := Fr } = { onFunction := Gf, onRelation := Gr }",
" Ff = Gf ∧ Fr = Gr",
" LHom.id L' ∘ᴸ F = F",
" LHom.id L' ∘ᴸ { onFunction := onFunction✝, onRelation := onRelation✝ } =\n { onFunction := onFunction✝, onRelation... | [
" F = G",
" { onFunction := Ff, onRelation := Fr } = G",
" { onFunction := Ff, onRelation := Fr } = { onFunction := Gf, onRelation := Gr }",
" Ff = Gf ∧ Fr = Gr",
" LHom.id L' ∘ᴸ F = F",
" LHom.id L' ∘ᴸ { onFunction := onFunction✝, onRelation := onRelation✝ } =\n { onFunction := onFunction✝, onRelation... |
import Mathlib.Algebra.ContinuedFractions.Basic
import Mathlib.Algebra.GroupWithZero.Basic
#align_import algebra.continued_fractions.translations from "leanprover-community/mathlib"@"a7e36e48519ab281320c4d192da6a7b348ce40ad"
namespace GeneralizedContinuedFraction
section General
variable {α : Type*} {g : Gen... | Mathlib/Algebra/ContinuedFractions/Translations.lean | 62 | 63 | theorem part_denom_eq_s_b {gp : Pair α} (s_nth_eq : g.s.get? n = some gp) :
g.partialDenominators.get? n = some gp.b := by | simp [partialDenominators, s_nth_eq]
| [
" g.TerminatedAt n ↔ g.s.TerminatedAt n",
" g.TerminatedAt n ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ none = none",
" g.partialNumerators.get? n = none ↔ some val✝ = none",
" g.TerminatedAt n ↔ g.partialNumerators.get? n = none",... | [
" g.TerminatedAt n ↔ g.s.TerminatedAt n",
" g.TerminatedAt n ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ g.s.get? n = none",
" g.partialNumerators.get? n = none ↔ none = none",
" g.partialNumerators.get? n = none ↔ some val✝ = none",
" g.TerminatedAt n ↔ g.partialNumerators.get? n = none",... |
import Mathlib.Mathport.Rename
import Mathlib.Tactic.Lemma
import Mathlib.Tactic.TypeStar
#align_import data.option.defs from "leanprover-community/mathlib"@"c4658a649d216f57e99621708b09dcb3dcccbd23"
namespace Option
#align option.lift_or_get Option.liftOrGet
protected def traverse.{u, v}
{F : Type u → Type... | Mathlib/Data/Option/Defs.lean | 61 | 61 | theorem mem_some_iff {α : Type*} {a b : α} : a ∈ some b ↔ b = a := by | simp
| [
" Option.elim' b f a = a.elim b f",
" Option.elim' b f none = none.elim b f",
" Option.elim' b f (some val✝) = (some val✝).elim b f",
" a ∈ some b ↔ b = a"
] | [
" Option.elim' b f a = a.elim b f",
" Option.elim' b f none = none.elim b f",
" Option.elim' b f (some val✝) = (some val✝).elim b f"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.