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.Algebra.BigOperators.Group.Finset
import Mathlib.Data.Finset.Sym
import Mathlib.Data.Fintype.Sum
import Mathlib.Data.Fintype.Prod
#align_import data.sym.card from "leanprover-community/mathlib"@"0bd2ea37bcba5769e14866170f251c9bc64e35d7"
open Finset Fintype Function Sum Nat
variable {α β : Type*}
... | Mathlib/Data/Sym/Card.lean | 120 | 122 | theorem card_sym_eq_choose {α : Type*} [Fintype α] (k : ℕ) [Fintype (Sym α k)] :
card (Sym α k) = (card α + k - 1).choose k := by |
rw [card_sym_eq_multichoose, Nat.multichoose_eq]
| [
" (fun s => ⟨0 ::ₛ s, ⋯⟩) ((fun s => (↑s).erase 0 ⋯) s) = s",
" (fun s => (↑s).erase 0 ⋯) ((fun s => ⟨0 ::ₛ s, ⋯⟩) s) = s",
" (fun s => ⟨map (Fin.succAbove 0) s, ⋯⟩) ((fun s => map (Fin.predAbove 0) ↑s) s) = s",
" ↑((fun s => ⟨map (Fin.succAbove 0) s, ⋯⟩) ((fun s => map (Fin.predAbove 0) ↑s) s)) = ↑s",
" ma... | [
" (fun s => ⟨0 ::ₛ s, ⋯⟩) ((fun s => (↑s).erase 0 ⋯) s) = s",
" (fun s => (↑s).erase 0 ⋯) ((fun s => ⟨0 ::ₛ s, ⋯⟩) s) = s",
" (fun s => ⟨map (Fin.succAbove 0) s, ⋯⟩) ((fun s => map (Fin.predAbove 0) ↑s) s) = s",
" ↑((fun s => ⟨map (Fin.succAbove 0) s, ⋯⟩) ((fun s => map (Fin.predAbove 0) ↑s) s)) = ↑s",
" ma... |
import Mathlib.Order.SuccPred.Basic
import Mathlib.Topology.Order.Basic
import Mathlib.Topology.Metrizable.Uniformity
#align_import topology.instances.discrete from "leanprover-community/mathlib"@"bcfa726826abd57587355b4b5b7e78ad6527b7e4"
open Order Set TopologicalSpace Filter
variable {α : Type*} [TopologicalSp... | Mathlib/Topology/Instances/Discrete.lean | 80 | 108 | theorem LinearOrder.bot_topologicalSpace_eq_generateFrom [LinearOrder α] [PredOrder α]
[SuccOrder α] : (⊥ : TopologicalSpace α) = generateFrom { s | ∃ a, s = Ioi a ∨ s = Iio a } := by |
refine (eq_bot_of_singletons_open fun a => ?_).symm
have h_singleton_eq_inter : {a} = Iic a ∩ Ici a := by rw [inter_comm, Ici_inter_Iic, Icc_self a]
by_cases ha_top : IsTop a
· rw [ha_top.Iic_eq, inter_comm, inter_univ] at h_singleton_eq_inter
by_cases ha_bot : IsBot a
· rw [ha_bot.Ici_eq] at h_singlet... | [
" ∀ (a : α), (nhds a).IsCountablyGenerated",
" ∀ (a : α), (pure a).IsCountablyGenerated",
" instTopologicalSpaceSubtype = generateFrom {univ}",
" ⊥ = generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a}",
" IsOpen {a}",
" {a} = Iio (succ a) ∩ Ioi (pred a)",
" {a} = Iic a ∩ Ici a",
" IsOpen (Iio (succ a) ∩ Io... | [
" ∀ (a : α), (nhds a).IsCountablyGenerated",
" ∀ (a : α), (pure a).IsCountablyGenerated",
" instTopologicalSpaceSubtype = generateFrom {univ}",
" ⊥ = generateFrom {s | ∃ a, s = Ioi a ∨ s = Iio a}",
" IsOpen {a}",
" {a} = Iio (succ a) ∩ Ioi (pred a)",
" {a} = Iic a ∩ Ici a",
" IsOpen (Iio (succ a) ∩ Io... |
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import analysis.special_functions.complex.log from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
namespace Complex
open Set Filter Bornology
open scop... | Mathlib/Analysis/SpecialFunctions/Complex/Log.lean | 36 | 36 | theorem log_im (x : ℂ) : x.log.im = x.arg := by | simp [log]
| [
" x.log.re = (abs x).log",
" x.log.im = x.arg"
] | [
" x.log.re = (abs x).log"
] |
import Mathlib.LinearAlgebra.LinearPMap
import Mathlib.Topology.Algebra.Module.Basic
#align_import topology.algebra.module.linear_pmap from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Topology
variable {R E F : Type*}
variable [CommRing R] [AddCommGroup E] [AddCommGroup F]
vari... | Mathlib/Topology/Algebra/Module/LinearPMap.lean | 77 | 85 | theorem IsClosable.leIsClosable {f g : E →ₗ.[R] F} (hf : f.IsClosable) (hfg : g ≤ f) :
g.IsClosable := by |
cases' hf with f' hf
have : g.graph.topologicalClosure ≤ f'.graph := by
rw [← hf]
exact Submodule.topologicalClosure_mono (le_graph_of_le hfg)
use g.graph.topologicalClosure.toLinearPMap
rw [Submodule.toLinearPMap_graph_eq]
exact fun _ hx hx' => f'.graph_fst_eq_zero_snd (this hx) hx'
| [
" g.IsClosable",
" g.graph.topologicalClosure ≤ f'.graph",
" g.graph.topologicalClosure ≤ f.graph.topologicalClosure",
" g.graph.topologicalClosure = g.graph.topologicalClosure.toLinearPMap.graph",
" ∀ x ∈ g.graph.topologicalClosure, x.1 = 0 → x.2 = 0"
] | [] |
import Mathlib.MeasureTheory.Group.Measure
assert_not_exists NormedSpace
namespace MeasureTheory
open Measure TopologicalSpace
open scoped ENNReal
variable {G : Type*} [MeasurableSpace G] {μ : Measure G} {g : G}
section MeasurableMul
variable [Group G] [MeasurableMul G]
@[to_additive
"Translating a fu... | Mathlib/MeasureTheory/Group/LIntegral.lean | 34 | 37 | theorem lintegral_mul_left_eq_self [IsMulLeftInvariant μ] (f : G → ℝ≥0∞) (g : G) :
(∫⁻ x, f (g * x) ∂μ) = ∫⁻ x, f x ∂μ := by |
convert (lintegral_map_equiv f <| MeasurableEquiv.mulLeft g).symm
simp [map_mul_left_eq_self μ g]
| [
" ∫⁻ (x : G), f (g * x) ∂μ = ∫⁻ (x : G), f x ∂μ",
" μ = map (⇑(MeasurableEquiv.mulLeft g)) μ"
] | [] |
import Mathlib.Algebra.Group.Prod
import Mathlib.Order.Cover
#align_import algebra.support from "leanprover-community/mathlib"@"29cb56a7b35f72758b05a30490e1f10bd62c35c1"
assert_not_exists MonoidWithZero
open Set
namespace Function
variable {α β A B M N P G : Type*}
section One
variable [One M] [One N] [One P]
... | Mathlib/Algebra/Group/Support.lean | 119 | 122 | theorem mulSupport_disjoint_iff {f : α → M} {s : Set α} :
Disjoint (mulSupport f) s ↔ EqOn f 1 s := by |
simp_rw [← subset_compl_iff_disjoint_right, mulSupport_subset_iff', not_mem_compl_iff, EqOn,
Pi.one_apply]
| [
" mulSupport f = s ↔ (∀ x ∈ s, f x ≠ 1) ∧ ∀ x ∉ s, f x = 1",
" f x = g x",
" mulSupport (update f x y) = insert x (mulSupport f)",
" a ∈ mulSupport (update f x y) ↔ a ∈ insert x (mulSupport f)",
" a ∈ mulSupport (update f a y) ↔ a ∈ insert a (mulSupport f)",
" mulSupport (update f x 1) = mulSupport f \\ {... | [
" mulSupport f = s ↔ (∀ x ∈ s, f x ≠ 1) ∧ ∀ x ∉ s, f x = 1",
" f x = g x",
" mulSupport (update f x y) = insert x (mulSupport f)",
" a ∈ mulSupport (update f x y) ↔ a ∈ insert x (mulSupport f)",
" a ∈ mulSupport (update f a y) ↔ a ∈ insert a (mulSupport f)",
" mulSupport (update f x 1) = mulSupport f \\ {... |
import Mathlib.AlgebraicGeometry.OpenImmersion
-- Explicit universe annotations were used in this file to improve perfomance #12737
set_option linter.uppercaseLean3 false
noncomputable section
open TopologicalSpace CategoryTheory Opposite
open CategoryTheory.Limits
namespace AlgebraicGeometry
universe v v₁ v₂... | Mathlib/AlgebraicGeometry/Restrict.lean | 131 | 135 | theorem Scheme.restrictFunctor_map_base {U V : Opens X} (i : U ⟶ V) :
(X.restrictFunctor.map i).1.1.base = (Opens.toTopCat _).map i := by |
ext a; refine Subtype.ext ?_ -- Porting note: `ext` did not pick up `Subtype.ext`
exact (congr_arg (fun f : X.restrict U.openEmbedding ⟶ X => f.1.base a)
(X.restrictFunctor_map_ofRestrict i))
| [
" ⋯.functor.obj ((Opens.map (X.ofRestrict ⋯).val.base).op.obj { unop := U }).unop = U",
" ⋯.functor.obj ((X ∣_ᵤ U).basicOpen r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)",
" X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)",
" X.basicOpen ((Hom.invApp (... | [
" ⋯.functor.obj ((Opens.map (X.ofRestrict ⋯).val.base).op.obj { unop := U }).unop = U",
" ⋯.functor.obj ((X ∣_ᵤ U).basicOpen r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)",
" X.basicOpen ((Hom.invApp (X.ofRestrict ⋯) ⊤) r) = X.basicOpen ((X.presheaf.map (eqToHom ⋯).op) r)",
" X.basicOpen ((Hom.invApp (... |
import Mathlib.Topology.Separation
#align_import topology.sober from "leanprover-community/mathlib"@"0a0ec35061ed9960bf0e7ffb0335f44447b58977"
open Set
variable {α β : Type*} [TopologicalSpace α] [TopologicalSpace β]
section genericPoint
def IsGenericPoint (x : α) (S : Set α) : Prop :=
closure ({x} : Set α)... | Mathlib/Topology/Sober.lean | 53 | 54 | theorem isGenericPoint_iff_specializes : IsGenericPoint x S ↔ ∀ y, x ⤳ y ↔ y ∈ S := by |
simp only [specializes_iff_mem_closure, IsGenericPoint, Set.ext_iff]
| [
" IsGenericPoint x S ↔ ∀ (y : α), x ⤳ y ↔ y ∈ S"
] | [] |
import Mathlib.Analysis.NormedSpace.Real
import Mathlib.Analysis.Seminorm
import Mathlib.Topology.MetricSpace.HausdorffDistance
#align_import analysis.normed_space.riesz_lemma from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Set Metric
open Topology
variable {𝕜 : Type*} [Norm... | Mathlib/Analysis/NormedSpace/RieszLemma.lean | 41 | 70 | theorem riesz_lemma {F : Subspace 𝕜 E} (hFc : IsClosed (F : Set E)) (hF : ∃ x : E, x ∉ F) {r : ℝ}
(hr : r < 1) : ∃ x₀ : E, x₀ ∉ F ∧ ∀ y ∈ F, r * ‖x₀‖ ≤ ‖x₀ - y‖ := by |
classical
obtain ⟨x, hx⟩ : ∃ x : E, x ∉ F := hF
let d := Metric.infDist x F
have hFn : (F : Set E).Nonempty := ⟨_, F.zero_mem⟩
have hdp : 0 < d :=
lt_of_le_of_ne Metric.infDist_nonneg fun heq =>
hx ((hFc.mem_iff_infDist_zero hFn).2 heq.symm)
let r' := max r 2⁻¹
have hr' : r' < 1... | [
" ∃ x₀ ∉ F, ∀ y ∈ F, r * ‖x₀‖ ≤ ‖x₀ - y‖",
" r' < 1",
" 2⁻¹ < 1",
" 0 < 2⁻¹",
" x - y₀ ∉ F",
" False",
" r * ‖x - y₀‖ < ‖x - y₀ - y‖",
" r * ‖x - y₀‖ ≤ r' * ‖x - y₀‖",
" r ≤ r'",
" r' * ‖x - y₀‖ < d",
" r' * dist x y₀ < d",
" dist x (y₀ + y) = ‖x - y₀ - y‖"
] | [] |
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 | 85 | 87 | theorem opRingEquiv_symm_C_mul_X_pow (r : Rᵐᵒᵖ) (n : ℕ) :
(opRingEquiv R).symm (C r * X ^ n : Rᵐᵒᵖ[X]) = op (C (unop r) * X ^ n) := by |
rw [C_mul_X_pow_eq_monomial, opRingEquiv_symm_monomial, C_mul_X_pow_eq_monomial]
| [
" (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) (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))"
] |
import Mathlib.LinearAlgebra.FiniteDimensional
import Mathlib.MeasureTheory.Group.Pointwise
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
import Mathlib.MeasureTheory.Measure.Haar.Basic
import Mathlib.MeasureTheory.Measure.Doubling
import Mathlib.MeasureTheory.Constructions.BorelSpace.Metric
#align_import measu... | Mathlib/MeasureTheory/Measure/Lebesgue/EqHaar.lean | 120 | 124 | theorem addHaarMeasure_eq_volume_pi (ι : Type*) [Fintype ι] :
addHaarMeasure (piIcc01 ι) = volume := by |
convert (addHaarMeasure_unique volume (piIcc01 ι)).symm
simp only [piIcc01, volume_pi_pi fun _ => Icc (0 : ℝ) 1, PositiveCompacts.coe_mk,
Compacts.coe_mk, Finset.prod_const_one, ENNReal.ofReal_one, Real.volume_Icc, one_smul, sub_zero]
| [
" (interior { carrier := Icc 0 1, isCompact' := ⋯ }.carrier).Nonempty",
" (interior { carrier := univ.pi fun x => Icc 0 1, isCompact' := ⋯ }.carrier).Nonempty",
" ↑(Pi.basisFun ℝ ι).parallelepiped = ↑(PositiveCompacts.piIcc01 ι)",
" ↑(Pi.basisFun ℝ ι).parallelepiped = uIcc (fun i => 0) fun i => 1",
" (fun i... | [
" (interior { carrier := Icc 0 1, isCompact' := ⋯ }.carrier).Nonempty",
" (interior { carrier := univ.pi fun x => Icc 0 1, isCompact' := ⋯ }.carrier).Nonempty",
" ↑(Pi.basisFun ℝ ι).parallelepiped = ↑(PositiveCompacts.piIcc01 ι)",
" ↑(Pi.basisFun ℝ ι).parallelepiped = uIcc (fun i => 0) fun i => 1",
" (fun i... |
import Mathlib.MeasureTheory.Group.GeometryOfNumbers
import Mathlib.MeasureTheory.Measure.Lebesgue.VolumeOfBalls
import Mathlib.NumberTheory.NumberField.CanonicalEmbedding.Basic
#align_import number_theory.number_field.canonical_embedding from "leanprover-community/mathlib"@"60da01b41bbe4206f05d34fd70c8dd7498717a30"
... | Mathlib/NumberTheory/NumberField/CanonicalEmbedding/ConvexBody.lean | 70 | 75 | theorem convexBodyLT_neg_mem (x : E K) (hx : x ∈ (convexBodyLT K f)) :
-x ∈ (convexBodyLT K f) := by |
simp only [Set.mem_prod, Prod.fst_neg, Set.mem_pi, Set.mem_univ, Pi.neg_apply,
mem_ball_zero_iff, norm_neg, Real.norm_eq_abs, forall_true_left, Subtype.forall,
Prod.snd_neg, Complex.norm_eq_abs] at hx ⊢
exact hx
| [
" (mixedEmbedding K) x ∈ convexBodyLT K f ↔ ∀ (w : InfinitePlace K), w x < ↑(f w)",
" -x ∈ convexBodyLT K f",
" (∀ (a : InfinitePlace K) (b : a.IsReal), |x.1 ⟨a, b⟩| < ↑(f a)) ∧\n ∀ (a : InfinitePlace K) (b : a.IsComplex), Complex.abs (x.2 ⟨a, b⟩) < ↑(f a)"
] | [
" (mixedEmbedding K) x ∈ convexBodyLT K f ↔ ∀ (w : InfinitePlace K), w x < ↑(f w)"
] |
import Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar
import Mathlib.MeasureTheory.Covering.Besicovitch
import Mathlib.Tactic.AdaptationNote
#align_import measure_theory.covering.besicovitch_vector_space from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
universe u
open Metric Set Fini... | Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean | 83 | 84 | theorem centerAndRescale_center : a.centerAndRescale.c (last N) = 0 := by |
simp [SatelliteConfig.centerAndRescale]
| [
" 0 < (fun i => (a.r (last N))⁻¹ * a.r i) i",
" (fun i j =>\n (fun i => (a.r (last N))⁻¹ * a.r i) i ≤\n dist ((fun i => (a.r (last N))⁻¹ • (a.c i - a.c (last N))) i)\n ((fun i => (a.r (last N))⁻¹ • (a.c i - a.c (last N))) j) ∧\n (fun i => (a.r (last N))⁻¹ * a.r i) j ≤ τ * (fu... | [
" 0 < (fun i => (a.r (last N))⁻¹ * a.r i) i",
" (fun i j =>\n (fun i => (a.r (last N))⁻¹ * a.r i) i ≤\n dist ((fun i => (a.r (last N))⁻¹ • (a.c i - a.c (last N))) i)\n ((fun i => (a.r (last N))⁻¹ • (a.c i - a.c (last N))) j) ∧\n (fun i => (a.r (last N))⁻¹ * a.r i) j ≤ τ * (fu... |
import Mathlib.CategoryTheory.Filtered.Connected
import Mathlib.CategoryTheory.Limits.TypesFiltered
import Mathlib.CategoryTheory.Limits.Final
universe v₁ v₂ u₁ u₂
namespace CategoryTheory
open CategoryTheory.Limits CategoryTheory.Functor Opposite
section ArbitraryUniverses
variable {C : Type u₁} [Category.{v₁}... | Mathlib/CategoryTheory/Filtered/Final.lean | 91 | 95 | theorem Functor.final_of_exists_of_isFiltered [IsFilteredOrEmpty C]
(h₁ : ∀ d, ∃ c, Nonempty (d ⟶ F.obj c)) (h₂ : ∀ {d : D} {c : C} (s s' : d ⟶ F.obj c),
∃ (c' : C) (t : c ⟶ c'), s ≫ F.map t = s' ≫ F.map t) : Functor.Final F := by |
suffices ∀ d, IsFiltered (StructuredArrow d F) from final_of_isFiltered_structuredArrow F
exact isFiltered_structuredArrow_of_isFiltered_of_exists F h₁ h₂
| [
" IsFiltered (StructuredArrow d F)",
" Nonempty (StructuredArrow d F)",
" IsFilteredOrEmpty (StructuredArrow d F)",
" ∃ Z x x, True",
" f ⟶ StructuredArrow.mk (f.hom ≫ F.map (IsFiltered.leftToMax f.right g.right ≫ t))",
" g ⟶ StructuredArrow.mk (f.hom ≫ F.map (IsFiltered.leftToMax f.right g.right ≫ t))",
... | [
" IsFiltered (StructuredArrow d F)",
" Nonempty (StructuredArrow d F)",
" IsFilteredOrEmpty (StructuredArrow d F)",
" ∃ Z x x, True",
" f ⟶ StructuredArrow.mk (f.hom ≫ F.map (IsFiltered.leftToMax f.right g.right ≫ t))",
" g ⟶ StructuredArrow.mk (f.hom ≫ F.map (IsFiltered.leftToMax f.right g.right ≫ t))",
... |
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 | 45 | 48 | theorem stdBasisMatrix_zero (i : m) (j : n) : stdBasisMatrix i j (0 : α) = 0 := by |
unfold stdBasisMatrix
ext
simp
| [
" 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"
] |
import Mathlib.Data.PNat.Defs
import Mathlib.Algebra.Order.Ring.Nat
import Mathlib.Data.Set.Basic
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Algebra.Order.Positive.Ring
import Mathlib.Order.Hom.Basic
#align_import data.pnat.basic from "leanprover-community/mathlib"@"172bf2812857f5e56938cc148b7a5... | Mathlib/Data/PNat/Basic.lean | 33 | 34 | theorem one_add_natPred (n : ℕ+) : 1 + n.natPred = n := by |
rw [natPred, add_tsub_cancel_iff_le.mpr <| show 1 ≤ (n : ℕ) from n.2]
| [
" 1 + n.natPred = ↑n"
] | [] |
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 | 221 | 224 | theorem card_sigmaLift :
(sigmaLift f a b).card = dite (a.1 = b.1) (fun h => (f (h ▸ a.2) b.2).card) fun _ => 0 := by |
simp_rw [sigmaLift]
split_ifs with h <;> simp [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.Order.Interval.Set.Disjoint
import Mathlib.MeasureTheory.Integral.SetIntegral
import Mathlib.MeasureTheory.Measure.Lebesgue.Basic
#align_import measure_theory.integral.interval_integral from "leanprover-community/mathlib"@"fd5edc43dc4f10b85abfe544b88f82cf13c5f844"
noncomputable section
open scoped... | Mathlib/MeasureTheory/Integral/IntervalIntegral.lean | 108 | 110 | theorem intervalIntegrable_iff_integrableOn_Ico_of_le [NoAtoms μ] (hab : a ≤ b) :
IntervalIntegrable f μ a b ↔ IntegrableOn f (Ico a b) μ := by |
rw [intervalIntegrable_iff_integrableOn_Icc_of_le hab, integrableOn_Icc_iff_integrableOn_Ico]
| [
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Ι a b) μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Ioc a b) μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f [[a, b]] μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Icc a b) μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Ico a b) μ"
] | [
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Ι a b) μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Ioc a b) μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f [[a, b]] μ",
" IntervalIntegrable f μ a b ↔ IntegrableOn f (Icc a b) μ"
] |
import Mathlib.RingTheory.FiniteType
#align_import ring_theory.rees_algebra from "leanprover-community/mathlib"@"70fd9563a21e7b963887c9360bd29b2393e6225a"
universe u v
variable {R M : Type u} [CommRing R] [AddCommGroup M] [Module R M] (I : Ideal R)
open Polynomial
open Polynomial
def reesAlgebra : Subalgebra... | Mathlib/RingTheory/ReesAlgebra.lean | 76 | 79 | theorem reesAlgebra.monomial_mem {I : Ideal R} {i : ℕ} {r : R} :
monomial i r ∈ reesAlgebra I ↔ r ∈ I ^ i := by |
simp (config := { contextual := true }) [mem_reesAlgebra_iff_support, coeff_monomial, ←
imp_iff_not_or]
| [
" (a✝ * b✝).coeff i ∈ I ^ i",
" ∑ x ∈ Finset.antidiagonal i, a✝.coeff x.1 * b✝.coeff x.2 ∈ I ^ i",
" ∀ c ∈ Finset.antidiagonal i, a✝.coeff c.1 * b✝.coeff c.2 ∈ I ^ i",
" a✝.coeff (j, k).1 * b✝.coeff (j, k).2 ∈ I ^ i",
" a✝.coeff (j, k).1 * b✝.coeff (j, k).2 ∈ I ^ (j, k).1 * I ^ (j, k).2",
" coeff 1 i ∈ I ... | [
" (a✝ * b✝).coeff i ∈ I ^ i",
" ∑ x ∈ Finset.antidiagonal i, a✝.coeff x.1 * b✝.coeff x.2 ∈ I ^ i",
" ∀ c ∈ Finset.antidiagonal i, a✝.coeff c.1 * b✝.coeff c.2 ∈ I ^ i",
" a✝.coeff (j, k).1 * b✝.coeff (j, k).2 ∈ I ^ i",
" a✝.coeff (j, k).1 * b✝.coeff (j, k).2 ∈ I ^ (j, k).1 * I ^ (j, k).2",
" coeff 1 i ∈ I ... |
import Mathlib.CategoryTheory.NatTrans
import Mathlib.CategoryTheory.Iso
#align_import category_theory.functor.category from "leanprover-community/mathlib"@"63721b2c3eba6c325ecf8ae8cca27155a4f6306f"
namespace CategoryTheory
-- declare the `v`'s first; see note [CategoryTheory universes].
universe v₁ v₂ v₃ u₁ u₂ u... | Mathlib/CategoryTheory/Functor/Category.lean | 132 | 134 | theorem exchange {I J K : D ⥤ E} (α : F ⟶ G) (β : G ⟶ H) (γ : I ⟶ J) (δ : J ⟶ K) :
(α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫ δ := by |
aesop_cat
| [
" α.app X = β.app X",
" g = h",
" g.app X = h.app X",
" (F ⋙ H).map f ≫ (fun X => β.app (F.obj X) ≫ I.map (α.app X)) Y =\n (fun X => β.app (F.obj X) ≫ I.map (α.app X)) X ≫ (G ⋙ I).map f",
" (α ◫ 𝟙 H).app X = H.map (α.app X)",
" (𝟙 H ◫ α).app X = α.app (H.obj X)",
" (α ≫ β) ◫ (γ ≫ δ) = (α ◫ γ) ≫ β ◫... | [
" α.app X = β.app X",
" g = h",
" g.app X = h.app X",
" (F ⋙ H).map f ≫ (fun X => β.app (F.obj X) ≫ I.map (α.app X)) Y =\n (fun X => β.app (F.obj X) ≫ I.map (α.app X)) X ≫ (G ⋙ I).map f",
" (α ◫ 𝟙 H).app X = H.map (α.app X)",
" (𝟙 H ◫ α).app X = α.app (H.obj X)"
] |
import Mathlib.Algebra.MvPolynomial.Counit
import Mathlib.Algebra.MvPolynomial.Invertible
import Mathlib.RingTheory.WittVector.Defs
#align_import ring_theory.witt_vector.basic from "leanprover-community/mathlib"@"9556784a5b84697562e9c6acb40500d4a82e675a"
noncomputable section
open MvPolynomial Function
variable... | Mathlib/RingTheory/WittVector/Basic.lean | 102 | 102 | theorem zero : mapFun f (0 : 𝕎 R) = 0 := by | map_fun_tac
| [
" Injective (mapFun f)",
" a₁✝ = a₂✝",
" a₁✝.coeff p = a₂✝.coeff p",
" mapFun f (mk p fun n => Classical.choose ⋯) = x",
" (mapFun f (mk p fun n => Classical.choose ⋯)).coeff n = x.coeff n",
" mapFun (⇑f) 0 = 0"
] | [
" Injective (mapFun f)",
" a₁✝ = a₂✝",
" a₁✝.coeff p = a₂✝.coeff p",
" mapFun f (mk p fun n => Classical.choose ⋯) = x",
" (mapFun f (mk p fun n => Classical.choose ⋯)).coeff n = x.coeff n"
] |
import Mathlib.Topology.Algebra.Constructions
import Mathlib.Topology.Bases
import Mathlib.Topology.UniformSpace.Basic
#align_import topology.uniform_space.cauchy from "leanprover-community/mathlib"@"22131150f88a2d125713ffa0f4693e3355b1eb49"
universe u v
open scoped Classical
open Filter TopologicalSpace Set Uni... | Mathlib/Topology/UniformSpace/Cauchy.lean | 70 | 72 | theorem cauchy_map_iff {l : Filter β} {f : β → α} :
Cauchy (l.map f) ↔ NeBot l ∧ Tendsto (fun p : β × β => (f p.1, f p.2)) (l ×ˢ l) (𝓤 α) := by |
rw [Cauchy, map_neBot_iff, prod_map_map_eq, Tendsto]
| [
" (∀ (i' : ι), p i' → ∃ i ∈ f, id i ×ˢ id i ⊆ s i') ↔ ∀ (i : ι), p i → ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s i",
" (f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s) ↔ f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s",
" Cauchy l ↔ l ×ˢ l ≤ 𝓤 α",
" Cauchy ↑(Ultrafilter.of l)",
" Cauchy (map f l) ↔ l.Ne... | [
" (∀ (i' : ι), p i' → ∃ i ∈ f, id i ×ˢ id i ⊆ s i') ↔ ∀ (i : ι), p i → ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s i",
" (f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, ∀ x ∈ t, ∀ y ∈ t, (x, y) ∈ s) ↔ f.NeBot ∧ ∀ s ∈ 𝓤 α, ∃ t ∈ f, t ×ˢ t ⊆ s",
" Cauchy l ↔ l ×ˢ l ≤ 𝓤 α",
" Cauchy ↑(Ultrafilter.of l)"
] |
import Mathlib.Data.DFinsupp.Interval
import Mathlib.Data.DFinsupp.Multiset
import Mathlib.Order.Interval.Finset.Nat
#align_import data.multiset.interval from "leanprover-community/mathlib"@"1d29de43a5ba4662dd33b5cfeecfc2a27a5a8a29"
open Finset DFinsupp Function
open Pointwise
variable {α : Type*}
namespace Mu... | Mathlib/Data/Multiset/Interval.lean | 62 | 64 | theorem card_Ico :
(Finset.Ico s t).card = ∏ i ∈ s.toFinset ∪ t.toFinset, (t.count i + 1 - s.count i) - 1 := by |
rw [Finset.card_Ico_eq_card_Icc_sub_one, card_Icc]
| [
" x ∈ (fun s t => Finset.map equivDFinsupp.symm.toEmbedding (Finset.Icc (toDFinsupp s) (toDFinsupp t))) s t ↔\n s ≤ x ∧ x ≤ t",
" Finset.map equivDFinsupp.symm.toEmbedding (Finset.Icc (toDFinsupp (s ⊓ t)) (toDFinsupp (s ⊔ t))) =\n Finset.map equivDFinsupp.symm.toEmbedding (uIcc (toDFinsupp s) (toDFinsupp t)... | [
" x ∈ (fun s t => Finset.map equivDFinsupp.symm.toEmbedding (Finset.Icc (toDFinsupp s) (toDFinsupp t))) s t ↔\n s ≤ x ∧ x ≤ t",
" Finset.map equivDFinsupp.symm.toEmbedding (Finset.Icc (toDFinsupp (s ⊓ t)) (toDFinsupp (s ⊔ t))) =\n Finset.map equivDFinsupp.symm.toEmbedding (uIcc (toDFinsupp s) (toDFinsupp t)... |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Data.Set.Pointwise.SMul
import Mathlib.Dynamics.FixedPoints.Basic
#align_import data.set.pointwise.iterate from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Pointwise
open Set Function
@[to_additive
"Let `n : ℤ`... | Mathlib/Data/Set/Pointwise/Iterate.lean | 31 | 42 | theorem smul_eq_self_of_preimage_zpow_eq_self {G : Type*} [CommGroup G] {n : ℤ} {s : Set G}
(hs : (fun x => x ^ n) ⁻¹' s = s) {g : G} {j : ℕ} (hg : g ^ n ^ j = 1) : g • s = s := by |
suffices ∀ {g' : G} (_ : g' ^ n ^ j = 1), g' • s ⊆ s by
refine le_antisymm (this hg) ?_
conv_lhs => rw [← smul_inv_smul g s]
replace hg : g⁻¹ ^ n ^ j = 1 := by rw [inv_zpow, hg, inv_one]
simpa only [le_eq_subset, set_smul_subset_set_smul_iff] using this hg
rw [(IsFixedPt.preimage_iterate hs j : (zp... | [
" g • s = s",
" s ≤ g • s",
"G : Type u_1\ninst✝ : CommGroup G\nn : ℤ\ns : Set G\nhs : (fun x => x ^ n) ⁻¹' s = s\ng : G\nj : ℕ\nhg : g ^ n ^ j = 1\nthis : ∀ {g' : G}, g' ^ n ^ j = 1 → g' • s ⊆ s\n| s",
" g • g⁻¹ • s ≤ g • s",
" g⁻¹ ^ n ^ j = 1",
" ∀ {g' : G}, g' ^ n ^ j = 1 → g' • s ⊆ s",
" ∀ {g' : G},... | [] |
import Mathlib.Data.List.Range
import Mathlib.Data.List.Perm
#align_import data.list.sigma from "leanprover-community/mathlib"@"f808feb6c18afddb25e66a71d317643cf7fb5fbb"
universe u v
namespace List
variable {α : Type u} {β : α → Type v} {l l₁ l₂ : List (Sigma β)}
def keys : List (Sigma β) → List α :=
map ... | Mathlib/Data/List/Sigma.lean | 102 | 103 | theorem nodupKeys_cons {s : Sigma β} {l : List (Sigma β)} :
NodupKeys (s :: l) ↔ s.1 ∉ l.keys ∧ NodupKeys l := by | simp [keys, NodupKeys]
| [
" s.fst ∉ l.keys",
" (s :: l).NodupKeys ↔ s.fst ∉ l.keys ∧ l.NodupKeys"
] | [
" s.fst ∉ l.keys"
] |
import Mathlib.Topology.PartialHomeomorph
import Mathlib.Topology.SeparatedMap
#align_import topology.is_locally_homeomorph from "leanprover-community/mathlib"@"e97cf15cd1aec9bd5c193b2ffac5a6dc9118912b"
open Topology
variable {X Y Z : Type*} [TopologicalSpace X] [TopologicalSpace Y] [TopologicalSpace Z] (g : Y →... | Mathlib/Topology/IsLocalHomeomorph.lean | 66 | 77 | theorem mk (h : ∀ x ∈ s, ∃ e : PartialHomeomorph X Y, x ∈ e.source ∧ Set.EqOn f e e.source) :
IsLocalHomeomorphOn f s := by |
intro x hx
obtain ⟨e, hx, he⟩ := h x hx
exact
⟨{ e with
toFun := f
map_source' := fun _x hx ↦ by rw [he hx]; exact e.map_source' hx
left_inv' := fun _x hx ↦ by rw [he hx]; exact e.left_inv' hx
right_inv' := fun _y hy ↦ by rw [he (e.map_target' hy)]; exact e.right_inv' hy
... | [
" IsLocalHomeomorphOn f s ↔ ∀ x ∈ s, ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict f)",
" ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict f)",
" ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict ↑e)",
" ∃ e, x ∈ e.source ∧ f = ↑e",
" OpenEmbedding ((interior U).restrict f)",
" IsOpen (Set.range (Set.inclusion ⋯))",
" IsOpen {x | ↑x ... | [
" IsLocalHomeomorphOn f s ↔ ∀ x ∈ s, ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict f)",
" ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict f)",
" ∃ U ∈ 𝓝 x, OpenEmbedding (U.restrict ↑e)",
" ∃ e, x ∈ e.source ∧ f = ↑e",
" OpenEmbedding ((interior U).restrict f)",
" IsOpen (Set.range (Set.inclusion ⋯))",
" IsOpen {x | ↑x ... |
import Mathlib.Data.Set.Image
import Mathlib.Order.Interval.Set.Basic
#align_import data.set.intervals.with_bot_top from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
open Set
variable {α : Type*}
namespace WithTop
@[simp]
theorem preimage_coe_top : (some : α → WithTop α) ⁻¹' {⊤} =... | Mathlib/Order/Interval/Set/WithBotTop.lean | 97 | 99 | theorem image_coe_Iio : (some : α → WithTop α) '' Iio a = Iio (a : WithTop α) := by |
rw [← preimage_coe_Iio, image_preimage_eq_inter_range, range_coe,
inter_eq_self_of_subset_left (Iio_subset_Iio le_top)]
| [
" range some = Iio ⊤",
" x ∈ range some ↔ x ∈ Iio ⊤",
" some ⁻¹' Icc ↑a ↑b = Icc a b",
" some ⁻¹' Ico ↑a ↑b = Ico a b",
" some ⁻¹' Ioc ↑a ↑b = Ioc a b",
" some ⁻¹' Ioo ↑a ↑b = Ioo a b",
" some ⁻¹' Iio ⊤ = univ",
" some ⁻¹' Ico ↑a ⊤ = Ici a",
" some ⁻¹' Ioo ↑a ⊤ = Ioi a",
" some '' Ioi a = Ioo ↑a ⊤... | [
" range some = Iio ⊤",
" x ∈ range some ↔ x ∈ Iio ⊤",
" some ⁻¹' Icc ↑a ↑b = Icc a b",
" some ⁻¹' Ico ↑a ↑b = Ico a b",
" some ⁻¹' Ioc ↑a ↑b = Ioc a b",
" some ⁻¹' Ioo ↑a ↑b = Ioo a b",
" some ⁻¹' Iio ⊤ = univ",
" some ⁻¹' Ico ↑a ⊤ = Ici a",
" some ⁻¹' Ioo ↑a ⊤ = Ioi a",
" some '' Ioi a = Ioo ↑a ⊤... |
import Mathlib.Algebra.Order.Group.Nat
import Mathlib.Data.Finset.Antidiagonal
import Mathlib.Data.Finset.Card
import Mathlib.Data.Multiset.NatAntidiagonal
#align_import data.finset.nat_antidiagonal from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
open Function
namespace Finset
name... | Mathlib/Data/Finset/NatAntidiagonal.lean | 67 | 75 | theorem antidiagonal_succ (n : ℕ) :
antidiagonal (n + 1) =
cons (0, n + 1)
((antidiagonal n).map
(Embedding.prodMap ⟨Nat.succ, Nat.succ_injective⟩ (Embedding.refl _)))
(by simp) := by |
apply eq_of_veq
rw [cons_val, map_val]
apply Multiset.Nat.antidiagonal_succ
| [
" xy ∈ (fun n => { val := Multiset.Nat.antidiagonal n, nodup := ⋯ }) n ↔ xy.1 + xy.2 = n",
" antidiagonal n = map { toFun := fun i => (n - i, i), inj' := ⋯ } (range (n + 1))",
" map ({ toFun := fun i => (i, n - i), inj' := ⋯ }.trans { toFun := Prod.swap, inj' := ⋯ }) (range (n + 1)) =\n map { toFun := fun i ... | [
" xy ∈ (fun n => { val := Multiset.Nat.antidiagonal n, nodup := ⋯ }) n ↔ xy.1 + xy.2 = n",
" antidiagonal n = map { toFun := fun i => (n - i, i), inj' := ⋯ } (range (n + 1))",
" map ({ toFun := fun i => (i, n - i), inj' := ⋯ }.trans { toFun := Prod.swap, inj' := ⋯ }) (range (n + 1)) =\n map { toFun := fun i ... |
import Mathlib.Topology.MetricSpace.Isometry
#align_import topology.metric_space.gluing from "leanprover-community/mathlib"@"e1a7bdeb4fd826b7e71d130d34988f0a2d26a177"
noncomputable section
universe u v w
open Function Set Uniformity Topology
namespace Metric
namespace Sigma
variable {ι : Type*} {E : ι → Type... | Mathlib/Topology/MetricSpace/Gluing.lean | 352 | 355 | theorem one_le_dist_of_ne {i j : ι} (h : i ≠ j) (x : E i) (y : E j) :
1 ≤ dist (⟨i, x⟩ : Σk, E k) ⟨j, y⟩ := by |
rw [Sigma.dist_ne h x y]
linarith [@dist_nonneg _ _ x (Nonempty.some ⟨x⟩), @dist_nonneg _ _ (Nonempty.some ⟨y⟩) y]
| [
" E j = E i",
" dist ⟨i, x⟩ ⟨i, y⟩ = dist x y",
" 1 ≤ dist ⟨i, x⟩ ⟨j, y⟩",
" 1 ≤ dist x ⋯.some + 1 + dist ⋯.some y"
] | [
" E j = E i",
" dist ⟨i, x⟩ ⟨i, y⟩ = dist x y"
] |
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Data.Nat.Cast.Order
import Mathlib.Tactic.Common
#align_import data.nat.cast.field from "leanprover-community/mathlib"@"acee671f47b8e7972a1eb6f4eed74b4b3abce829"
namespace Nat
variable {α : Type*}
@[simp]
| Mathlib/Data/Nat/Cast/Field.lean | 29 | 33 | theorem cast_div [DivisionSemiring α] {m n : ℕ} (n_dvd : n ∣ m) (hn : (n : α) ≠ 0) :
((m / n : ℕ) : α) = m / n := by |
rcases n_dvd with ⟨k, rfl⟩
have : n ≠ 0 := by rintro rfl; simp at hn
rw [Nat.mul_div_cancel_left _ this.bot_lt, mul_comm n, cast_mul, mul_div_cancel_right₀ _ hn]
| [
" ↑(m / n) = ↑m / ↑n",
" ↑(n * k / n) = ↑(n * k) / ↑n",
" n ≠ 0",
" False"
] | [] |
import Mathlib.LinearAlgebra.CliffordAlgebra.Contraction
variable {R M : Type*}
variable [CommRing R] [AddCommGroup M] [Module R M] {Q : QuadraticForm R M}
namespace CliffordAlgebra
variable (Q)
def invertibleιOfInvertible (m : M) [Invertible (Q m)] : Invertible (ι Q m) where
invOf := ι Q (⅟ (Q m) • m)
invO... | Mathlib/LinearAlgebra/CliffordAlgebra/Inversion.lean | 51 | 54 | theorem invOf_ι_mul_ι_mul_ι (a b : M) [Invertible (ι Q a)] [Invertible (Q a)] :
⅟ (ι Q a) * ι Q b * ι Q a = ι Q ((⅟ (Q a) * QuadraticForm.polar Q a b) • a - b) := by |
rw [invOf_ι, map_smul, smul_mul_assoc, smul_mul_assoc, ι_mul_ι_mul_ι, ← map_smul, smul_sub,
smul_smul, smul_smul, invOf_mul_self, one_smul]
| [
" (ι Q) (⅟(Q m) • m) * (ι Q) m = 1",
" (ι Q) m * (ι Q) (⅟(Q m) • m) = 1",
" ⅟((ι Q) m) = (ι Q) (⅟(Q m) • m)",
" IsUnit ((ι Q) m)",
" (ι Q) a * (ι Q) b * ⅟((ι Q) a) = (ι Q) ((⅟(Q a) * QuadraticForm.polar (⇑Q) a b) • a - b)",
" ⅟((ι Q) a) * (ι Q) b * (ι Q) a = (ι Q) ((⅟(Q a) * QuadraticForm.polar (⇑Q) a b) ... | [
" (ι Q) (⅟(Q m) • m) * (ι Q) m = 1",
" (ι Q) m * (ι Q) (⅟(Q m) • m) = 1",
" ⅟((ι Q) m) = (ι Q) (⅟(Q m) • m)",
" IsUnit ((ι Q) m)",
" (ι Q) a * (ι Q) b * ⅟((ι Q) a) = (ι Q) ((⅟(Q a) * QuadraticForm.polar (⇑Q) a b) • a - b)"
] |
import Mathlib.Algebra.BigOperators.Intervals
import Mathlib.Topology.Algebra.InfiniteSum.Order
import Mathlib.Topology.Instances.Real
import Mathlib.Topology.Instances.ENNReal
#align_import topology.algebra.infinite_sum.real from "leanprover-community/mathlib"@"9a59dcb7a2d06bf55da57b9030169219980660cd"
open Filte... | Mathlib/Topology/Algebra/InfiniteSum/Real.lean | 67 | 70 | theorem not_summable_iff_tendsto_nat_atTop_of_nonneg {f : ℕ → ℝ} (hf : ∀ n, 0 ≤ f n) :
¬Summable f ↔ Tendsto (fun n : ℕ => ∑ i ∈ Finset.range n, f i) atTop atTop := by |
lift f to ℕ → ℝ≥0 using hf
exact mod_cast NNReal.not_summable_iff_tendsto_nat_atTop
| [
" CauchySeq f",
" ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)",
" Summable d",
" dist (f n) a ≤ ∑' (m : ℕ), d (n + m)",
" dist (f n) (f m) ≤ ∑' (m : ℕ), d (n + m)",
" ∑ i ∈ Ico n m, d i ≤ ∑' (m : ℕ), d (n + m)",
" ∑ k ∈ range (m - n), d (n + k) ≤ ∑' (m : ℕ), d (n + m)",
" Summable fun k => d (n + k)",
... | [
" CauchySeq f",
" ∀ (n : ℕ), edist (f n) (f n.succ) ≤ ↑(d n)",
" Summable d",
" dist (f n) a ≤ ∑' (m : ℕ), d (n + m)",
" dist (f n) (f m) ≤ ∑' (m : ℕ), d (n + m)",
" ∑ i ∈ Ico n m, d i ≤ ∑' (m : ℕ), d (n + m)",
" ∑ k ∈ range (m - n), d (n + k) ≤ ∑' (m : ℕ), d (n + m)",
" Summable fun k => d (n + k)",
... |
import Mathlib.Algebra.BigOperators.WithTop
import Mathlib.Algebra.GroupWithZero.Divisibility
import Mathlib.Data.ENNReal.Basic
#align_import data.real.ennreal from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open Set NNReal ENNReal
namespace ENNReal
variable {a b c d : ℝ≥0∞} {r p q... | Mathlib/Data/ENNReal/Operations.lean | 235 | 235 | theorem mul_ne_top : a ≠ ∞ → b ≠ ∞ → a * b ≠ ∞ := by | simpa only [lt_top_iff_ne_top] using mul_lt_top
| [
" (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal",
" (↑r₁ + r₂).toNNReal = (↑r₁).toNNReal + r₂.toNNReal",
" (↑r₁ + ↑r₂).toNNReal = (↑r₁).toNNReal + (↑r₂).toNNReal",
" ¬x < ⊤ ↔ x = ⊤",
" a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤",
" a * ⊤ = if a = 0 then 0 else ⊤",
" ⊤ * a = if a = 0 then 0 else ⊤",
" ⊤ ^ (m + 1) = ⊤"... | [
" (r₁ + r₂).toNNReal = r₁.toNNReal + r₂.toNNReal",
" (↑r₁ + r₂).toNNReal = (↑r₁).toNNReal + r₂.toNNReal",
" (↑r₁ + ↑r₂).toNNReal = (↑r₁).toNNReal + (↑r₂).toNNReal",
" ¬x < ⊤ ↔ x = ⊤",
" a + b ≠ ⊤ ↔ a ≠ ⊤ ∧ b ≠ ⊤",
" a * ⊤ = if a = 0 then 0 else ⊤",
" ⊤ * a = if a = 0 then 0 else ⊤",
" ⊤ ^ (m + 1) = ⊤"... |
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 | 143 | 144 | theorem factorization_eq_zero_of_not_dvd {n p : ℕ} (h : ¬p ∣ n) : n.factorization p = 0 := by |
simp [factorization_eq_zero_iff, h]
| [
" ∀ (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.AlgebraicGeometry.OpenImmersion
import Mathlib.AlgebraicGeometry.Morphisms.QuasiCompact
import Mathlib.CategoryTheory.MorphismProperty.Composition
import Mathlib.RingTheory.LocalProperties
universe v u
open CategoryTheory
namespace AlgebraicGeometry
class IsClosedImmersion {X Y : Scheme} (f : X ⟶... | Mathlib/AlgebraicGeometry/Morphisms/ClosedImmersion.lean | 98 | 112 | theorem of_comp {X Y Z : Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) [IsClosedImmersion g]
[IsClosedImmersion (f ≫ g)] : IsClosedImmersion f where
base_closed := by |
have h := closedEmbedding (f ≫ g)
rw [Scheme.comp_val_base] at h
apply closedEmbedding_of_continuous_injective_closed (Scheme.Hom.continuous f)
· exact Function.Injective.of_comp h.inj
· intro Z hZ
rw [ClosedEmbedding.closed_iff_image_closed (closedEmbedding g),
← Set.image_comp]
... | [
" IsClosedImmersion (f ≫ g)",
" Function.Surjective ⇑(PresheafedSpace.stalkMap (f ≫ g).val x)",
" Function.Surjective ⇑(PresheafedSpace.stalkMap g.val (f.val.base x) ≫ PresheafedSpace.stalkMap f.val x)",
" MorphismProperty.RespectsIso @IsClosedImmersion",
" ∀ {X Y Z : Scheme} (e : X ≅ Y) (f : Y ⟶ Z), IsClos... | [
" IsClosedImmersion (f ≫ g)",
" Function.Surjective ⇑(PresheafedSpace.stalkMap (f ≫ g).val x)",
" Function.Surjective ⇑(PresheafedSpace.stalkMap g.val (f.val.base x) ≫ PresheafedSpace.stalkMap f.val x)",
" MorphismProperty.RespectsIso @IsClosedImmersion",
" ∀ {X Y Z : Scheme} (e : X ≅ Y) (f : Y ⟶ Z), IsClos... |
import Mathlib.Analysis.SpecialFunctions.Gamma.Basic
import Mathlib.Analysis.SpecialFunctions.PolarCoord
import Mathlib.Analysis.Convex.Complex
#align_import analysis.special_functions.gaussian from "leanprover-community/mathlib"@"7982767093ae38cba236487f9c9dd9cd99f63c16"
noncomputable section
open Real Set Measu... | Mathlib/Analysis/SpecialFunctions/Gaussian/GaussianIntegral.lean | 51 | 55 | theorem rpow_mul_exp_neg_mul_rpow_isLittleO_exp_neg (s : ℝ) {b p : ℝ} (hp : 1 < p) (hb : 0 < b) :
(fun x : ℝ => x ^ s * exp (- b * x ^ p)) =o[atTop] fun x : ℝ => exp (-(1 / 2) * x) := by |
apply ((isBigO_refl (fun x : ℝ => x ^ s) atTop).mul_isLittleO
(exp_neg_mul_rpow_isLittleO_exp_neg hb hp)).trans
simpa only [mul_comm] using Real.Gamma_integrand_isLittleO s
| [
" (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - -b * x ^ p) atTop atTop",
" (fun x => x * (b * x ^ (p - 1) + -1)) =ᶠ[atTop] fun x => -x - -b * x ^ p",
" x * (b * x ^ (p - 1) + -1) = -x - -b * x ^ p",
" x * (b * (x ^ p / x) + -1) = -x - -b * x ^ p",
" b * x ^ p + -x =... | [
" (fun x => rexp (-b * x ^ p)) =o[atTop] fun x => rexp (-x)",
" Tendsto (fun x => -x - -b * x ^ p) atTop atTop",
" (fun x => x * (b * x ^ (p - 1) + -1)) =ᶠ[atTop] fun x => -x - -b * x ^ p",
" x * (b * x ^ (p - 1) + -1) = -x - -b * x ^ p",
" x * (b * (x ^ p / x) + -1) = -x - -b * x ^ p",
" b * x ^ p + -x =... |
import Mathlib.LinearAlgebra.Matrix.Determinant.Basic
import Mathlib.LinearAlgebra.Matrix.SesquilinearForm
import Mathlib.LinearAlgebra.Matrix.Symmetric
#align_import linear_algebra.quadratic_form.basic from "leanprover-community/mathlib"@"d11f435d4e34a6cea0a1797d6b625b0c170be845"
universe u v w
variable {S T : ... | Mathlib/LinearAlgebra/QuadraticForm/Basic.lean | 116 | 123 | theorem polar_add_left_iff {f : M → R} {x x' y : M} :
polar f (x + x') y = polar f x y + polar f x' y ↔
f (x + x' + y) + (f x + f x' + f y) = f (x + x') + f (x' + y) + f (y + x) := by |
simp only [← add_assoc]
simp only [polar, sub_eq_iff_eq_add, eq_sub_iff_add_eq, sub_add_eq_add_sub, add_sub]
simp only [add_right_comm _ (f y) _, add_right_comm _ (f x') (f x)]
rw [add_comm y x, add_right_comm _ _ (f (x + y)), add_comm _ (f (x + y)),
add_right_comm (f (x + y)), add_left_inj]
| [
" polar (f + g) x y = polar f x y + polar g x y",
" f (x + y) + g (x + y) - (f x + g x) - (f y + g y) = f (x + y) - f x - f y + (g (x + y) - g x - g y)",
" polar (-f) x y = -polar f x y",
" polar (s • f) x y = s • polar f x y",
" polar f x y = polar f y x",
" polar f (x + x') y = polar f x y + polar f x' ... | [
" polar (f + g) x y = polar f x y + polar g x y",
" f (x + y) + g (x + y) - (f x + g x) - (f y + g y) = f (x + y) - f x - f y + (g (x + y) - g x - g y)",
" polar (-f) x y = -polar f x y",
" polar (s • f) x y = s • polar f x y",
" polar f x y = polar f y x"
] |
import Mathlib.Analysis.NormedSpace.AddTorsorBases
#align_import analysis.convex.intrinsic from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
open AffineSubspace Set
open scoped Pointwise
variable {𝕜 V W Q P : Type*}
section AddTorsor
variable (𝕜) [Ring 𝕜] [AddCommGroup V] [Modu... | Mathlib/Analysis/Convex/Intrinsic.lean | 116 | 116 | theorem intrinsicFrontier_empty : intrinsicFrontier 𝕜 (∅ : Set P) = ∅ := by | simp [intrinsicFrontier]
| [
" intrinsicInterior 𝕜 ∅ = ∅",
" intrinsicFrontier 𝕜 ∅ = ∅"
] | [
" intrinsicInterior 𝕜 ∅ = ∅"
] |
import Mathlib.Analysis.Convex.Cone.InnerDual
import Mathlib.Algebra.Order.Nonneg.Module
import Mathlib.Algebra.Module.Submodule.Basic
variable {𝕜 E F G : Type*}
local notation3 "𝕜≥0" => {c : 𝕜 // 0 ≤ c}
abbrev PointedCone (𝕜 E) [OrderedSemiring 𝕜] [AddCommMonoid E] [Module 𝕜 E] :=
Submodule {c : 𝕜 // 0... | Mathlib/Analysis/Convex/Cone/Pointed.lean | 51 | 52 | theorem toConvexCone_pointed (S : PointedCone 𝕜 E) : (S : ConvexCone 𝕜 E).Pointed := by |
simp [toConvexCone, ConvexCone.Pointed]
| [
" ↑x✝¹ = ↑x✝ → x✝¹ = x✝",
" (↑S).Pointed"
] | [
" ↑x✝¹ = ↑x✝ → x✝¹ = x✝"
] |
import Batteries.Data.RBMap.Alter
import Batteries.Data.List.Lemmas
namespace Batteries
namespace RBNode
open RBColor
attribute [simp] fold foldl foldr Any forM foldlM Ordered
@[simp] theorem min?_reverse (t : RBNode α) : t.reverse.min? = t.max? := by
unfold RBNode.max?; split <;> simp [RBNode.min?]
unfold RB... | .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean | 35 | 36 | theorem Any_def {t : RBNode α} : t.Any p ↔ ∃ x ∈ t, p x := by |
induction t <;> simp [or_and_right, exists_or, *]
| [
" t.reverse.min? = t.max?",
" t.reverse.min? =\n match t with\n | nil => none\n | node c l v nil => some v\n | node c l v r => r.max?",
" nil.reverse.min? = none",
" (node c✝ l✝ v✝ nil).reverse.min? = some v✝",
" (node c✝ l✝ v✝ r✝).reverse.min? = r✝.max?",
" (node c✝ r✝.reverse v✝ l✝.reverse).... | [
" t.reverse.min? = t.max?",
" t.reverse.min? =\n match t with\n | nil => none\n | node c l v nil => some v\n | node c l v r => r.max?",
" nil.reverse.min? = none",
" (node c✝ l✝ v✝ nil).reverse.min? = some v✝",
" (node c✝ l✝ v✝ r✝).reverse.min? = r✝.max?",
" (node c✝ r✝.reverse v✝ l✝.reverse).... |
import Mathlib.LinearAlgebra.Basis.VectorSpace
import Mathlib.LinearAlgebra.Dimension.Finite
import Mathlib.SetTheory.Cardinal.Subfield
import Mathlib.LinearAlgebra.Dimension.RankNullity
#align_import linear_algebra.dimension from "leanprover-community/mathlib"@"47a5f8186becdbc826190ced4312f8199f9db6a5"
noncomput... | Mathlib/LinearAlgebra/Dimension/DivisionRing.lean | 304 | 311 | theorem rank_dual_eq_card_dual_of_aleph0_le_rank' {V : Type*} [AddCommGroup V] [Module K V]
(h : ℵ₀ ≤ Module.rank K V) : Module.rank Kᵐᵒᵖ (V →ₗ[K] K) = #(V →ₗ[K] K) := by |
obtain ⟨⟨ι, b⟩⟩ := Module.Free.exists_basis (R := K) (M := V)
rw [← b.mk_eq_rank'', aleph0_le_mk_iff] at h
have e := (b.constr Kᵐᵒᵖ (M' := K)).symm.trans
(LinearEquiv.piCongrRight fun _ ↦ MulOpposite.opLinearEquiv Kᵐᵒᵖ)
rw [e.rank_eq, e.toEquiv.cardinal_eq]
apply rank_fun_infinite
| [
" max ℵ₀ #K ≤ Module.rank K (ℕ → K)",
" Injective ⇑Finsupp.lcoeFun",
" #K ≤ Module.rank K (ℕ → K)",
" False",
" #↥L < #K",
" #(ιK × ℕ) < #K",
" ℵ₀ ≤ #ιL",
" #K ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ #↥L",
" ℵ₀ ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ ℵ₀",
" ∑ i ∈ t, g i • (⇑bL ∘ ⇑e) i = 0",
" ∑ x ∈ t, ∑... | [
" max ℵ₀ #K ≤ Module.rank K (ℕ → K)",
" Injective ⇑Finsupp.lcoeFun",
" #K ≤ Module.rank K (ℕ → K)",
" False",
" #↥L < #K",
" #(ιK × ℕ) < #K",
" ℵ₀ ≤ #ιL",
" #K ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ #↥L",
" ℵ₀ ≤ #↥L",
" #↥L ^ Fintype.card ιL ≤ ℵ₀",
" ∑ i ∈ t, g i • (⇑bL ∘ ⇑e) i = 0",
" ∑ x ∈ t, ∑... |
import Mathlib.Topology.Instances.Irrational
import Mathlib.Topology.Instances.Rat
import Mathlib.Topology.Compactification.OnePoint
#align_import topology.instances.rat_lemmas from "leanprover-community/mathlib"@"92ca63f0fb391a9ca5f22d2409a6080e786d99f7"
open Set Metric Filter TopologicalSpace
open Topology One... | Mathlib/Topology/Instances/RatLemmas.lean | 77 | 79 | theorem not_secondCountableTopology_opc : ¬SecondCountableTopology ℚ∞ := by |
intro
exact not_firstCountableTopology_opc inferInstance
| [
" (cocompact ℚ ⊓ 𝓝 p).NeBot",
" ∀ {i : Set ℚ × Set ℚ}, IsCompact i.1 ∧ p ∈ i.2 ∧ IsOpen i.2 → (i.1ᶜ ∩ i.2).Nonempty",
" ((s, o).1ᶜ ∩ (s, o).2).Nonempty",
" ((s, o).2 ∩ (s, o).1ᶜ).Nonempty",
" ¬(cocompact ℚ).IsCountablyGenerated",
" False",
" ¬(𝓝 ∞).IsCountablyGenerated",
" (comap OnePoint.some (𝓝 ∞... | [
" (cocompact ℚ ⊓ 𝓝 p).NeBot",
" ∀ {i : Set ℚ × Set ℚ}, IsCompact i.1 ∧ p ∈ i.2 ∧ IsOpen i.2 → (i.1ᶜ ∩ i.2).Nonempty",
" ((s, o).1ᶜ ∩ (s, o).2).Nonempty",
" ((s, o).2 ∩ (s, o).1ᶜ).Nonempty",
" ¬(cocompact ℚ).IsCountablyGenerated",
" False",
" ¬(𝓝 ∞).IsCountablyGenerated",
" (comap OnePoint.some (𝓝 ∞... |
import Mathlib.Algebra.Ring.Defs
import Mathlib.Algebra.Group.Ext
local macro:max "local_hAdd[" type:term ", " inst:term "]" : term =>
`(term| (letI := $inst; HAdd.hAdd : $type → $type → $type))
local macro:max "local_hMul[" type:term ", " inst:term "]" : term =>
`(term| (letI := $inst; HMul.hMul : $type → $typ... | Mathlib/Algebra/Ring/Ext.lean | 519 | 520 | theorem toRing_injective : Function.Injective (@toRing R) := by |
rintro ⟨⟩ ⟨⟩ _; congr
| [
" inst₁ = inst₂",
" toAddMonoid = toAddMonoid",
" HAdd.hAdd = HAdd.hAdd",
" NatCast.natCast = NatCast.natCast",
" NatCast.natCast n = NatCast.natCast n",
" NatCast.natCast 0 = NatCast.natCast 0",
" 0 = 0",
" NatCast.natCast (n + 1) = NatCast.natCast (n + 1)",
" NatCast.natCast n + 1 = NatCast.natCas... | [
" inst₁ = inst₂",
" toAddMonoid = toAddMonoid",
" HAdd.hAdd = HAdd.hAdd",
" NatCast.natCast = NatCast.natCast",
" NatCast.natCast n = NatCast.natCast n",
" NatCast.natCast 0 = NatCast.natCast 0",
" 0 = 0",
" NatCast.natCast (n + 1) = NatCast.natCast (n + 1)",
" NatCast.natCast n + 1 = NatCast.natCas... |
import Mathlib.Geometry.Manifold.VectorBundle.Tangent
#align_import geometry.manifold.mfderiv from "leanprover-community/mathlib"@"e473c3198bb41f68560cab68a0529c854b618833"
noncomputable section
open scoped Classical Topology Manifold
open Set ChartedSpace
section DerivativesDefinitions
variable {𝕜 : Type*} ... | Mathlib/Geometry/Manifold/MFDeriv/Defs.lean | 134 | 177 | theorem differentiable_within_at_localInvariantProp :
(contDiffGroupoid ⊤ I).LocalInvariantProp (contDiffGroupoid ⊤ I')
(DifferentiableWithinAtProp I I') :=
{ is_local := by |
intro s x u f u_open xu
have : I.symm ⁻¹' (s ∩ u) ∩ Set.range I = I.symm ⁻¹' s ∩ Set.range I ∩ I.symm ⁻¹' u := by
simp only [Set.inter_right_comm, Set.preimage_inter]
rw [DifferentiableWithinAtProp, DifferentiableWithinAtProp, this]
symm
apply differentiableWithinAt_inter
ha... | [
" ∀ {s : Set H} {x : H} {u : Set H} {f : H → H'},\n IsOpen u → x ∈ u → (DifferentiableWithinAtProp I I' f s x ↔ DifferentiableWithinAtProp I I' f (s ∩ u) x)",
" DifferentiableWithinAtProp I I' f s x ↔ DifferentiableWithinAtProp I I' f (s ∩ u) x",
" ↑I.symm ⁻¹' (s ∩ u) ∩ range ↑I = ↑I.symm ⁻¹' s ∩ range ↑I ∩ ... | [] |
import Mathlib.CategoryTheory.Opposites
#align_import category_theory.eq_to_hom from "leanprover-community/mathlib"@"dc6c365e751e34d100e80fe6e314c3c3e0fd2988"
universe v₁ v₂ v₃ u₁ u₂ u₃
-- morphism levels before object levels. See note [CategoryTheory universes].
namespace CategoryTheory
open Opposite
variable ... | Mathlib/CategoryTheory/EqToHom.lean | 104 | 107 | theorem congrArg_cast_hom_left {X Y Z : C} (p : X = Y) (q : Y ⟶ Z) :
cast (congrArg (fun W : C => W ⟶ Z) p.symm) q = eqToHom p ≫ q := by |
cases p
simp
| [
" X ⟶ Y",
" Y ⟶ Y",
" eqToHom p ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯",
" f = (f ≫ eqToHom p) ≫ eqToHom ⋯",
" f ≫ eqToHom p = g",
" g = eqToHom ⋯ ≫ eqToHom p ≫ g",
" eqToHom p ≫ eqToHom ⋯ ≫ f = f",
" g j = g j'",
" f j = f j'",
" z ... | [
" X ⟶ Y",
" Y ⟶ Y",
" eqToHom p ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom q = eqToHom ⋯",
" eqToHom ⋯ ≫ eqToHom ⋯ = eqToHom ⋯",
" f = (f ≫ eqToHom p) ≫ eqToHom ⋯",
" f ≫ eqToHom p = g",
" g = eqToHom ⋯ ≫ eqToHom p ≫ g",
" eqToHom p ≫ eqToHom ⋯ ≫ f = f",
" g j = g j'",
" f j = f j'",
" z ... |
import Mathlib.CategoryTheory.Limits.Preserves.Finite
import Mathlib.CategoryTheory.Sites.Canonical
import Mathlib.CategoryTheory.Sites.Coherent.Basic
import Mathlib.CategoryTheory.Sites.Preserves
universe v u w
namespace CategoryTheory
open Limits
variable {C : Type u} [Category.{v} C]
variable [FinitaryPreExten... | Mathlib/CategoryTheory/Sites/Coherent/ExtensiveSheaves.lean | 64 | 70 | theorem extensiveTopology.isSheaf_yoneda_obj (W : C) : Presieve.IsSheaf (extensiveTopology C)
(yoneda.obj W) := by |
erw [isSheaf_coverage]
intro X R ⟨Y, α, Z, π, hR, hi⟩
have : IsIso (Sigma.desc (Cofan.inj (Cofan.mk X π))) := hi
have : R.Extensive := ⟨Y, α, Z, π, hR, ⟨Cofan.isColimitOfIsIsoSigmaDesc (Cofan.mk X π)⟩⟩
exact isSheafFor_extensive_of_preservesFiniteProducts _ _
| [
" ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g",
" ∀ {Y Z : C} {f : Y ⟶ X}, Presieve.ofArrows w✝¹ w✝ f → ∀ {g : Z ⟶ X}, Presieve.ofArrows w✝¹ w✝ g → HasPullback f g",
" HasPullback f✝ g✝",
" HasPullback f✝ (w✝ i✝)",
" IsSheafFor F S",
" IsSheafFor F (ofArrows Z π)",
" IsSheaf (ext... | [
" ∀ {Y Z : C} {f : Y ⟶ X}, S f → ∀ {g : Z ⟶ X}, S g → HasPullback f g",
" ∀ {Y Z : C} {f : Y ⟶ X}, Presieve.ofArrows w✝¹ w✝ f → ∀ {g : Z ⟶ X}, Presieve.ofArrows w✝¹ w✝ g → HasPullback f g",
" HasPullback f✝ g✝",
" HasPullback f✝ (w✝ i✝)",
" IsSheafFor F S",
" IsSheafFor F (ofArrows Z π)"
] |
import Mathlib.Algebra.DirectSum.Module
import Mathlib.Analysis.Complex.Basic
import Mathlib.Analysis.Convex.Uniform
import Mathlib.Analysis.NormedSpace.Completion
import Mathlib.Analysis.NormedSpace.BoundedLinearMaps
#align_import analysis.inner_product_space.basic from "leanprover-community/mathlib"@"3f655f5297b030... | Mathlib/Analysis/InnerProductSpace/Basic.lean | 224 | 226 | theorem ofReal_normSq_eq_inner_self (x : F) : (normSqF x : 𝕜) = ⟪x, x⟫ := by |
rw [ext_iff]
exact ⟨by simp only [ofReal_re]; rfl, by simp only [inner_self_im, ofReal_im]⟩
| [
" 0 ≤ re ⟪x, x⟫_𝕜",
" 0 ≤ ‖x‖ ^ 2",
" ‖x‖ ^ 2 = 0",
" im ⟪x, x⟫_𝕜 = 0",
" I * ((starRingEnd 𝕜) ⟪x, x⟫_𝕜 - ⟪x, x⟫_𝕜) / 2 = ↑0",
" ⟪x, y + z⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜",
" (starRingEnd 𝕜) ⟪y, x⟫_𝕜 + (starRingEnd 𝕜) ⟪z, x⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜",
" ↑(normSq x) = ⟪x, x⟫_𝕜",
" re ↑(normSq ... | [
" 0 ≤ re ⟪x, x⟫_𝕜",
" 0 ≤ ‖x‖ ^ 2",
" ‖x‖ ^ 2 = 0",
" im ⟪x, x⟫_𝕜 = 0",
" I * ((starRingEnd 𝕜) ⟪x, x⟫_𝕜 - ⟪x, x⟫_𝕜) / 2 = ↑0",
" ⟪x, y + z⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜",
" (starRingEnd 𝕜) ⟪y, x⟫_𝕜 + (starRingEnd 𝕜) ⟪z, x⟫_𝕜 = ⟪x, y⟫_𝕜 + ⟪x, z⟫_𝕜"
] |
import Mathlib.Order.Filter.Bases
import Mathlib.Order.Filter.Ultrafilter
open Set
variable {α β : Type*} {l : Filter α}
namespace Filter
protected def Subsingleton (l : Filter α) : Prop := ∃ s ∈ l, Set.Subsingleton s
theorem HasBasis.subsingleton_iff {ι : Sort*} {p : ι → Prop} {s : ι → Set α} (h : l.HasBasis p ... | Mathlib/Order/Filter/Subsingleton.lean | 65 | 68 | theorem subsingleton_iff_exists_le_pure [Nonempty α] : l.Subsingleton ↔ ∃ a, l ≤ pure a := by |
rcases eq_or_neBot l with rfl | hbot
· simp
· simp [subsingleton_iff_bot_or_pure, ← hbot.le_pure_iff, hbot.ne]
| [
" ∃ a, l = pure a",
" l ≤ pure a",
" l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a",
" l = ⊥ ∨ ∃ a, l = pure a",
" (l = ⊥ ∨ ∃ a, l = pure a) → l.Subsingleton",
" ⊥.Subsingleton",
" (pure a).Subsingleton",
" l.Subsingleton ↔ ∃ a, l ≤ pure a",
" ⊥.Subsingleton ↔ ∃ a, ⊥ ≤ pure a"
] | [
" ∃ a, l = pure a",
" l ≤ pure a",
" l.Subsingleton ↔ l = ⊥ ∨ ∃ a, l = pure a",
" l = ⊥ ∨ ∃ a, l = pure a",
" (l = ⊥ ∨ ∃ a, l = pure a) → l.Subsingleton",
" ⊥.Subsingleton",
" (pure a).Subsingleton"
] |
import Mathlib.Order.RelClasses
#align_import data.sigma.lex from "leanprover-community/mathlib"@"41cf0cc2f528dd40a8f2db167ea4fb37b8fde7f3"
namespace PSigma
variable {ι : Sort*} {α : ι → Sort*} {r r₁ r₂ : ι → ι → Prop} {s s₁ s₂ : ∀ i, α i → α i → Prop}
theorem lex_iff {a b : Σ' i, α i} :
Lex r s a b ↔ r ... | Mathlib/Data/Sigma/Lex.lean | 170 | 175 | theorem Lex.mono {r₁ r₂ : ι → ι → Prop} {s₁ s₂ : ∀ i, α i → α i → Prop}
(hr : ∀ a b, r₁ a b → r₂ a b) (hs : ∀ i a b, s₁ i a b → s₂ i a b) {a b : Σ' i, α i}
(h : Lex r₁ s₁ a b) : Lex r₂ s₂ a b := by |
obtain ⟨a, b, hij⟩ | ⟨i, hab⟩ := h
· exact Lex.left _ _ (hr _ _ hij)
· exact Lex.right _ (hs _ _ _ hab)
| [
" Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" r ⟨a₁✝, a⟩.fst ⟨a₂✝, b⟩.fst ∨ ∃ h, s ⟨a₂✝, b⟩.fst (h ▸ ⟨a₁✝, a⟩.snd) ⟨a₂✝, b⟩.snd",
" r ⟨i, b₁✝⟩.fst ⟨i, b₂✝⟩.fst ∨ ∃ h, s ⟨i, b₂✝⟩.fst (h ▸ ⟨i, b₁✝⟩.snd) ⟨i, b₂✝⟩.snd",
" (r a... | [
" Lex r s a b ↔ r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" Lex r s a b → r a.fst b.fst ∨ ∃ h, s b.fst (h ▸ a.snd) b.snd",
" r ⟨a₁✝, a⟩.fst ⟨a₂✝, b⟩.fst ∨ ∃ h, s ⟨a₂✝, b⟩.fst (h ▸ ⟨a₁✝, a⟩.snd) ⟨a₂✝, b⟩.snd",
" r ⟨i, b₁✝⟩.fst ⟨i, b₂✝⟩.fst ∨ ∃ h, s ⟨i, b₂✝⟩.fst (h ▸ ⟨i, b₁✝⟩.snd) ⟨i, b₂✝⟩.snd",
" (r a... |
import Mathlib.Data.Fintype.Card
import Mathlib.Data.List.MinMax
import Mathlib.Data.Nat.Order.Lemmas
import Mathlib.Logic.Encodable.Basic
#align_import logic.denumerable from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
variable {α β : Type*}
class Denumerable (α : Type*) extends E... | Mathlib/Logic/Denumerable.lean | 104 | 110 | theorem ofEquiv_ofNat (α) {β} [Denumerable α] (e : β ≃ α) (n) :
@ofNat β (ofEquiv _ e) n = e.symm (ofNat α n) := by |
-- Porting note: added `letI`
letI := ofEquiv _ e
refine ofNat_of_decode ?_
rw [decode_ofEquiv e]
simp
| [
" encode (ofNat α n) = n",
" ∃ a ∈ decode n, encode a = n",
" ofNat β n = e.symm (ofNat α n)",
" decode n = some (e.symm (ofNat α n))",
" Option.map (⇑e.symm) (decode n) = some (e.symm (ofNat α n))"
] | [
" encode (ofNat α n) = n",
" ∃ a ∈ decode n, encode a = n"
] |
import Mathlib.Analysis.SpecialFunctions.Complex.Arg
import Mathlib.Analysis.SpecialFunctions.Log.Basic
#align_import analysis.special_functions.complex.log from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
noncomputable section
namespace Complex
open Set Filter Bornology
open scop... | Mathlib/Analysis/SpecialFunctions/Complex/Log.lean | 42 | 42 | theorem log_im_le_pi (x : ℂ) : (log x).im ≤ π := by | simp only [log_im, arg_le_pi]
| [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -π < x.log.im",
" x.log.im ≤ π"
] | [
" x.log.re = (abs x).log",
" x.log.im = x.arg",
" -π < x.log.im"
] |
import Mathlib.Topology.LocalAtTarget
import Mathlib.AlgebraicGeometry.Morphisms.Basic
#align_import algebraic_geometry.morphisms.open_immersion from "leanprover-community/mathlib"@"f0c8bf9245297a541f468be517f1bde6195105e9"
noncomputable section
open CategoryTheory CategoryTheory.Limits Opposite TopologicalSpace... | Mathlib/AlgebraicGeometry/Morphisms/OpenImmersion.lean | 46 | 50 | theorem isOpenImmersion_respectsIso : MorphismProperty.RespectsIso @IsOpenImmersion := by |
apply MorphismProperty.respectsIso_of_isStableUnderComposition
intro _ _ f (hf : IsIso f)
have : IsIso f := hf
infer_instance
| [
" IsOpenImmersion f ↔\n OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (PresheafedSpace.stalkMap f.val x)",
" IsOpenImmersion f →\n OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (PresheafedSpace.stalkMap f.val x)",
" OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedS... | [
" IsOpenImmersion f ↔\n OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (PresheafedSpace.stalkMap f.val x)",
" IsOpenImmersion f →\n OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedSpace), IsIso (PresheafedSpace.stalkMap f.val x)",
" OpenEmbedding ⇑f.val.base ∧ ∀ (x : ↑↑X.toPresheafedS... |
import Mathlib.CategoryTheory.Comma.Over
import Mathlib.CategoryTheory.Limits.Shapes.Pullbacks
import Mathlib.CategoryTheory.Yoneda
import Mathlib.Data.Set.Lattice
import Mathlib.Order.CompleteLattice
#align_import category_theory.sites.sieves from "leanprover-community/mathlib"@"239d882c4fb58361ee8b3b39fb2091320edef... | Mathlib/CategoryTheory/Sites/Sieves.lean | 125 | 133 | theorem pullback_singleton [HasPullbacks C] (g : Z ⟶ X) :
pullbackArrows f (singleton g) = singleton (pullback.snd : pullback g f ⟶ _) := by |
funext W
ext h
constructor
· rintro ⟨W, _, _, _⟩
exact singleton.mk
· rintro ⟨_⟩
exact pullbackArrows.mk Z g singleton.mk
| [
" CompleteLattice (Presieve X)",
" CompleteLattice (⦃Y : C⦄ → Set (Y ⟶ X))",
" singleton f g ↔ f = g",
" singleton f g → f = g",
" f = f",
" f = g → singleton f g",
" singleton f f",
" pullbackArrows f (singleton g) = singleton pullback.snd",
" h ∈ pullbackArrows f (singleton g) ↔ h ∈ singleton pull... | [
" CompleteLattice (Presieve X)",
" CompleteLattice (⦃Y : C⦄ → Set (Y ⟶ X))",
" singleton f g ↔ f = g",
" singleton f g → f = g",
" f = f",
" f = g → singleton f g",
" singleton f f"
] |
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 | 67 | 76 | theorem cderiv_sub (hr : 0 < r) (hf : ContinuousOn f (sphere z r))
(hg : ContinuousOn g (sphere z r)) : cderiv r (f - g) z = cderiv r f z - cderiv r g z := by |
have h1 : ContinuousOn (fun w : ℂ => ((w - z) ^ 2)⁻¹) (sphere z r) := by
refine ((continuous_id'.sub continuous_const).pow 2).continuousOn.inv₀ fun w hw h => hr.ne ?_
rwa [mem_sphere_iff_norm, sq_eq_zero_iff.mp h, norm_zero] at hw
simp_rw [cderiv, ← smul_sub]
congr 1
simpa only [Pi.sub_apply, smul_sub]... | [
" ‖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.Analysis.NormedSpace.lpSpace
import Mathlib.Topology.Sets.Compacts
#align_import topology.metric_space.kuratowski from "leanprover-community/mathlib"@"95d4f6586d313c8c28e00f36621d2a6a66893aa6"
noncomputable section
set_option linter.uppercaseLean3 false
open Set Metric TopologicalSpace NNReal ENNR... | Mathlib/Topology/MetricSpace/Kuratowski.lean | 52 | 57 | theorem embeddingOfSubset_dist_le (a b : α) :
dist (embeddingOfSubset x a) (embeddingOfSubset x b) ≤ dist a b := by |
refine lp.norm_le_of_forall_le dist_nonneg fun n => ?_
simp only [lp.coeFn_sub, Pi.sub_apply, embeddingOfSubset_coe, Real.dist_eq]
convert abs_dist_sub_le a b (x n) using 2
ring
| [
" (fun n => dist a (x n) - dist (x 0) (x n)) ∈ lp (fun i => ℝ) ⊤",
" BddAbove (range fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖)",
" dist a (x 0) ∈ upperBounds (range fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖)",
" (fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖) n ≤ dist a ... | [
" (fun n => dist a (x n) - dist (x 0) (x n)) ∈ lp (fun i => ℝ) ⊤",
" BddAbove (range fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖)",
" dist a (x 0) ∈ upperBounds (range fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖)",
" (fun i => ‖(fun n => dist a (x n) - dist (x 0) (x n)) i‖) n ≤ dist a ... |
import Mathlib.Analysis.Normed.Order.Basic
import Mathlib.Analysis.Asymptotics.Asymptotics
import Mathlib.Analysis.NormedSpace.Basic
#align_import analysis.asymptotics.specific_asymptotics from "leanprover-community/mathlib"@"f2ce6086713c78a7f880485f7917ea547a215982"
open Filter Asymptotics
open Topology
sectio... | Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean | 98 | 128 | theorem Asymptotics.IsLittleO.sum_range {α : Type*} [NormedAddCommGroup α] {f : ℕ → α} {g : ℕ → ℝ}
(h : f =o[atTop] g) (hg : 0 ≤ g) (h'g : Tendsto (fun n => ∑ i ∈ range n, g i) atTop atTop) :
(fun n => ∑ i ∈ range n, f i) =o[atTop] fun n => ∑ i ∈ range n, g i := by |
have A : ∀ i, ‖g i‖ = g i := fun i => Real.norm_of_nonneg (hg i)
have B : ∀ n, ‖∑ i ∈ range n, g i‖ = ∑ i ∈ range n, g i := fun n => by
rwa [Real.norm_eq_abs, abs_sum_of_nonneg']
apply isLittleO_iff.2 fun ε εpos => _
intro ε εpos
obtain ⟨N, hN⟩ : ∃ N : ℕ, ∀ b : ℕ, N ≤ b → ‖f b‖ ≤ ε / 2 * g b := by
si... | [
" (fun n => ∑ i ∈ range n, f i) =o[atTop] fun n => ∑ i ∈ range n, g i",
" ‖∑ i ∈ range n, g i‖ = ∑ i ∈ range n, g i",
" ∀ (ε : ℝ), 0 < ε → ∀ᶠ (x : ℕ) in atTop, ‖∑ i ∈ range x, f i‖ ≤ ε * ‖∑ i ∈ range x, g i‖",
" ∀ᶠ (x : ℕ) in atTop, ‖∑ i ∈ range x, f i‖ ≤ ε * ‖∑ i ∈ range x, g i‖",
" ∃ N, ∀ (b : ℕ), N ≤ b →... | [] |
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Zip
import Mathlib.Data.Nat.Defs
import Mathlib.Data.List.Infix
#align_import data.list.rotate from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
universe u
variable {α : Type u}
open Nat Function
namespace List
theorem rotate... | Mathlib/Data/List/Rotate.lean | 67 | 76 | theorem rotate'_eq_drop_append_take :
∀ {l : List α} {n : ℕ}, n ≤ l.length → l.rotate' n = l.drop n ++ l.take n
| [], n, h => by simp [drop_append_of_le_length h]
| l, 0, h => by simp [take_append_of_le_length h]
| a :: l, n + 1, h => by
have hnl : n ≤ l.length := le_of_succ_le_succ h
have hnl' : n ≤ ... |
rw [length_append, length_cons, List.length]; exact le_of_succ_le h
rw [rotate'_cons_succ, rotate'_eq_drop_append_take hnl', drop, take,
drop_append_of_le_length hnl, take_append_of_le_length hnl]; simp
| [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []",
" l.rotate 0 = l",
" [].rotate' n = []",
" [].rotate' 0 = []",
" [].rotate' (n✝ + 1) = []",
" l.rotate' 0 = l",
" (head✝ :: tail✝).rotate' 0 = head✝ :: tail✝",
" (a :: l).rotate' n.succ = (l ++ [a]).rotate' n",
" ([].rotate' x✝).length ... | [
" l.rotate (n % l.length) = l.rotate n",
" [].rotate n = []",
" l.rotate 0 = l",
" [].rotate' n = []",
" [].rotate' 0 = []",
" [].rotate' (n✝ + 1) = []",
" l.rotate' 0 = l",
" (head✝ :: tail✝).rotate' 0 = head✝ :: tail✝",
" (a :: l).rotate' n.succ = (l ++ [a]).rotate' n",
" ([].rotate' x✝).length ... |
import Mathlib.Data.Matrix.Basis
import Mathlib.LinearAlgebra.Basis
import Mathlib.LinearAlgebra.Pi
#align_import linear_algebra.std_basis from "leanprover-community/mathlib"@"13bce9a6b6c44f6b4c91ac1c1d2a816e2533d395"
open Function Set Submodule
namespace LinearMap
variable (R : Type*) {ι : Type*} [Semiring R] ... | Mathlib/LinearAlgebra/StdBasis.lean | 96 | 103 | theorem iSup_range_stdBasis_le_iInf_ker_proj (I J : Set ι) (h : Disjoint I J) :
⨆ i ∈ I, range (stdBasis R φ i) ≤ ⨅ i ∈ J, ker (proj i : (∀ i, φ i) →ₗ[R] φ i) := by |
refine iSup_le fun i => iSup_le fun hi => range_le_iff_comap.2 ?_
simp only [← ker_comp, eq_top_iff, SetLike.le_def, mem_ker, comap_iInf, mem_iInf]
rintro b - j hj
rw [proj_stdBasis_ne R φ j i, zero_apply]
rintro rfl
exact h.le_bot ⟨hi, hj⟩
| [
" (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0",
" (if i' = i then 1 else 0) = if i = i' then 1 else 0",
" (i' = i) = (i = i')",
" stdBasis R φ i = pi (diag i)",
" (stdBasis R φ i) x j = (pi (diag i)) x j",
" x = id x",
" proj i ∘ₗ stdBasis R φ j = diag j i",
" ⨆ i ∈ I, range (stdBasis ... | [
" (stdBasis R (fun _x => R) i) 1 i' = if i = i' then 1 else 0",
" (if i' = i then 1 else 0) = if i = i' then 1 else 0",
" (i' = i) = (i = i')",
" stdBasis R φ i = pi (diag i)",
" (stdBasis R φ i) x j = (pi (diag i)) x j",
" x = id x",
" proj i ∘ₗ stdBasis R φ j = diag j i"
] |
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 | 170 | 172 | theorem symmDiff_sdiff_inf : a ∆ b \ (a ⊓ b) = a ∆ b := by |
rw [symmDiff_sdiff]
simp [symmDiff]
| [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ b = b ∆ a",
" a ∆ a = ⊥",
" a ∆ ⊥ = a",
" ⊥ ∆ a = a",
" a ∆ b = ⊥ ↔ a = b",
" a ∆ b = b \\ a",
" a ∆ b = a \\ b",
" a ∆ b ≤ c ↔ a ≤ b ⊔ c ∧ b ≤ a ⊔ c",
" a ∆ b = (a ⊔ b) \\ (a ⊓ b)",
" a ∆ b = a ⊔ b",
" a ∆ b \\ c = a \\ (b ⊔ c) ⊔ b \\ (a ⊔ c)",
" a ... | [
" ∀ (p q : Bool), p ∆ q = xor p q",
" a ∆ b = b ∆ a",
" a ∆ a = ⊥",
" a ∆ ⊥ = a",
" ⊥ ∆ a = a",
" a ∆ b = ⊥ ↔ a = b",
" a ∆ b = b \\ a",
" a ∆ b = a \\ b",
" a ∆ b ≤ c ↔ a ≤ b ⊔ c ∧ b ≤ a ⊔ c",
" a ∆ b = (a ⊔ b) \\ (a ⊓ b)",
" a ∆ b = a ⊔ b",
" a ∆ b \\ c = a \\ (b ⊔ c) ⊔ b \\ (a ⊔ c)"
] |
import Mathlib.RingTheory.DedekindDomain.Ideal
#align_import ring_theory.dedekind_domain.factorization from "leanprover-community/mathlib"@"2f588be38bb5bec02f218ba14f82fc82eb663f87"
noncomputable section
open scoped Classical nonZeroDivisors
open Set Function UniqueFactorizationMonoid IsDedekindDomain IsDedekind... | Mathlib/RingTheory/DedekindDomain/Factorization.lean | 68 | 76 | theorem Ideal.finite_factors {I : Ideal R} (hI : I ≠ 0) :
{v : HeightOneSpectrum R | v.asIdeal ∣ I}.Finite := by |
rw [← Set.finite_coe_iff, Set.coe_setOf]
haveI h_fin := fintypeSubtypeDvd I hI
refine
Finite.of_injective (fun v => (⟨(v : HeightOneSpectrum R).asIdeal, v.2⟩ : { x // x ∣ I })) ?_
intro v w hvw
simp? at hvw says simp only [Subtype.mk.injEq] at hvw
exact Subtype.coe_injective ((HeightOneSpectrum.ext_iff... | [
" {v | v.asIdeal ∣ I}.Finite",
" Finite { x // x.asIdeal ∣ I }",
" Injective fun v => ⟨(↑v).asIdeal, ⋯⟩",
" v = w"
] | [] |
import Mathlib.Analysis.MeanInequalities
import Mathlib.Analysis.NormedSpace.WithLp
open Real Set Filter RCLike Bornology Uniformity Topology NNReal ENNReal
noncomputable section
variable (p : ℝ≥0∞) (𝕜 α β : Type*)
namespace WithLp
section DistNorm
section Norm
variable [Norm α] [Norm β]
open scoped C... | Mathlib/Analysis/NormedSpace/ProdLp.lean | 270 | 272 | theorem prod_norm_eq_card (f : WithLp 0 (α × β)) :
‖f‖ = (if ‖f.fst‖ = 0 then 0 else 1) + (if ‖f.snd‖ = 0 then 0 else 1) := by |
convert if_pos rfl
| [
" ‖f‖ = (if ‖f.1‖ = 0 then 0 else 1) + if ‖f.2‖ = 0 then 0 else 1"
] | [] |
import Mathlib.MeasureTheory.Integral.SetIntegral
#align_import measure_theory.integral.average from "leanprover-community/mathlib"@"c14c8fcde993801fca8946b0d80131a1a81d1520"
open ENNReal MeasureTheory MeasureTheory.Measure Metric Set Filter TopologicalSpace Function
open scoped Topology ENNReal Convex
variable... | Mathlib/MeasureTheory/Integral/Average.lean | 169 | 180 | theorem laverage_add_measure :
⨍⁻ x, f x ∂(μ + ν) =
μ univ / (μ univ + ν univ) * ⨍⁻ x, f x ∂μ + ν univ / (μ univ + ν univ) * ⨍⁻ x, f x ∂ν := by |
by_cases hμ : IsFiniteMeasure μ; swap
· rw [not_isFiniteMeasure_iff] at hμ
simp [laverage_eq, hμ]
by_cases hν : IsFiniteMeasure ν; swap
· rw [not_isFiniteMeasure_iff] at hν
simp [laverage_eq, hν]
haveI := hμ; haveI := hν
simp only [← ENNReal.mul_div_right_comm, measure_mul_laverage, ← ENNReal.add_d... | [
" ⨍⁻ (_x : α), 0 ∂μ = 0",
" ⨍⁻ (x : α), f x ∂0 = 0",
" ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / μ univ",
" ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" ⨍⁻ (x : α) in s, f x ∂μ = (∫⁻ (x : α) in s, f x ∂μ) / μ s",
" ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α... | [
" ⨍⁻ (_x : α), 0 ∂μ = 0",
" ⨍⁻ (x : α), f x ∂0 = 0",
" ⨍⁻ (x : α), f x ∂μ = (∫⁻ (x : α), f x ∂μ) / μ univ",
" ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" μ univ * ⨍⁻ (x : α), f x ∂μ = ∫⁻ (x : α), f x ∂μ",
" ⨍⁻ (x : α) in s, f x ∂μ = (∫⁻ (x : α) in s, f x ∂μ) / μ s",
" ⨍⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α... |
import Mathlib.Algebra.Module.Submodule.Map
#align_import linear_algebra.basic from "leanprover-community/mathlib"@"9d684a893c52e1d6692a504a118bfccbae04feeb"
open Function
open Pointwise
variable {R : Type*} {R₁ : Type*} {R₂ : Type*} {R₃ : Type*}
variable {K : Type*}
variable {M : Type*} {M₁ : Type*} {M₂ : Type*... | Mathlib/Algebra/Module/Submodule/Ker.lean | 92 | 93 | theorem ker_le_ker_comp (f : M →ₛₗ[τ₁₂] M₂) (g : M₂ →ₛₗ[τ₂₃] M₃) :
ker f ≤ ker (g.comp f : M →ₛₗ[τ₁₃] M₃) := by | rw [ker_comp]; exact comap_mono bot_le
| [
" ker f ≤ ker (g.comp f)",
" ker f ≤ comap f (ker g)"
] | [] |
import Mathlib.Order.Interval.Set.Basic
import Mathlib.Order.Hom.Set
#align_import data.set.intervals.order_iso from "leanprover-community/mathlib"@"d012cd09a9b256d870751284dd6a29882b0be105"
open Set
namespace OrderIso
section Preorder
variable {α β : Type*} [Preorder α] [Preorder β]
@[simp]
theorem preimage_I... | Mathlib/Order/Interval/Set/OrderIso.lean | 63 | 64 | theorem preimage_Ioo (e : α ≃o β) (a b : β) : e ⁻¹' Ioo a b = Ioo (e.symm a) (e.symm b) := by |
simp [← Ioi_inter_Iio]
| [
" ⇑e ⁻¹' Iic b = Iic (e.symm b)",
" x ∈ ⇑e ⁻¹' Iic b ↔ x ∈ Iic (e.symm b)",
" ⇑e ⁻¹' Ici b = Ici (e.symm b)",
" x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)",
" ⇑e ⁻¹' Iio b = Iio (e.symm b)",
" x ∈ ⇑e ⁻¹' Iio b ↔ x ∈ Iio (e.symm b)",
" ⇑e ⁻¹' Ioi b = Ioi (e.symm b)",
" x ∈ ⇑e ⁻¹' Ioi b ↔ x ∈ Ioi (e.symm b)"... | [
" ⇑e ⁻¹' Iic b = Iic (e.symm b)",
" x ∈ ⇑e ⁻¹' Iic b ↔ x ∈ Iic (e.symm b)",
" ⇑e ⁻¹' Ici b = Ici (e.symm b)",
" x ∈ ⇑e ⁻¹' Ici b ↔ x ∈ Ici (e.symm b)",
" ⇑e ⁻¹' Iio b = Iio (e.symm b)",
" x ∈ ⇑e ⁻¹' Iio b ↔ x ∈ Iio (e.symm b)",
" ⇑e ⁻¹' Ioi b = Ioi (e.symm b)",
" x ∈ ⇑e ⁻¹' Ioi b ↔ x ∈ Ioi (e.symm b)"... |
import Mathlib.Topology.MetricSpace.HausdorffDistance
#align_import topology.metric_space.hausdorff_distance from "leanprover-community/mathlib"@"bc91ed7093bf098d253401e69df601fc33dde156"
noncomputable section
open NNReal ENNReal Topology Set Filter Bornology
universe u v w
variable {ι : Sort*} {α : Type u} {β :... | Mathlib/Topology/MetricSpace/Thickening.lean | 265 | 268 | theorem cthickening_singleton {α : Type*} [PseudoMetricSpace α] (x : α) {δ : ℝ} (hδ : 0 ≤ δ) :
cthickening δ ({x} : Set α) = closedBall x δ := by |
ext y
simp [cthickening, edist_dist, ENNReal.ofReal_le_ofReal_iff hδ]
| [
" ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E",
" x ∉ cthickening δ E",
" ENNReal.ofReal δ < infEdist x E",
" x ∈ cthickening δ E",
" edist x y ≤ ENNReal.ofReal δ",
" ENNReal.ofReal (dist x y) ≤ ENNReal.ofReal δ",
" cthickening δ ∅ = ∅",
" cthickening δ E = closure E",
" x ∈ cthickening δ E ↔ x ∈ closur... | [
" ∀ᶠ (δ : ℝ) in 𝓝 0, x ∉ cthickening δ E",
" x ∉ cthickening δ E",
" ENNReal.ofReal δ < infEdist x E",
" x ∈ cthickening δ E",
" edist x y ≤ ENNReal.ofReal δ",
" ENNReal.ofReal (dist x y) ≤ ENNReal.ofReal δ",
" cthickening δ ∅ = ∅",
" cthickening δ E = closure E",
" x ∈ cthickening δ E ↔ x ∈ closur... |
import Mathlib.Algebra.Group.Center
#align_import group_theory.subsemigroup.centralizer from "leanprover-community/mathlib"@"cc67cd75b4e54191e13c2e8d722289a89e67e4fa"
variable {M : Type*} {S T : Set M}
namespace Set
variable (S)
@[to_additive addCentralizer " The centralizer of a subset of an additive magma. ... | Mathlib/Algebra/Group/Centralizer.lean | 58 | 59 | theorem one_mem_centralizer [MulOneClass M] : (1 : M) ∈ centralizer S := by |
simp [mem_centralizer_iff]
| [
" 1 ∈ S.centralizer"
] | [] |
import Mathlib.Algebra.Order.Field.Basic
import Mathlib.Combinatorics.SimpleGraph.Basic
import Mathlib.Data.Rat.Cast.Order
import Mathlib.Order.Partition.Finpartition
import Mathlib.Tactic.GCongr
import Mathlib.Tactic.NormNum
import Mathlib.Tactic.Positivity
import Mathlib.Tactic.Ring
#align_import combinatorics.simp... | Mathlib/Combinatorics/SimpleGraph/Density.lean | 109 | 112 | theorem interedges_biUnion_left (s : Finset ι) (t : Finset β) (f : ι → Finset α) :
interedges r (s.biUnion f) t = s.biUnion fun a ↦ interedges r (f a) t := by |
ext
simp only [mem_biUnion, mem_interedges_iff, exists_and_right, ← and_assoc]
| [
" x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2",
" interedges r ∅ t = ∅",
" x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁",
" x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2",
" (interedges r s t).card + (interedges (fun x y => ¬r x y) s t).card = s.card * t.card",
" Disjoint (... | [
" x ∈ interedges r s t ↔ x.1 ∈ s ∧ x.2 ∈ t ∧ r x.1 x.2",
" interedges r ∅ t = ∅",
" x ∈ interedges r s₂ t₂ → x ∈ interedges r s₁ t₁",
" x.1 ∈ s₂ ∧ x.2 ∈ t₂ ∧ r x.1 x.2 → x.1 ∈ s₁ ∧ x.2 ∈ t₁ ∧ r x.1 x.2",
" (interedges r s t).card + (interedges (fun x y => ¬r x y) s t).card = s.card * t.card",
" Disjoint (... |
set_option autoImplicit true
namespace Array
@[simp]
| Mathlib/Data/Array/ExtractLemmas.lean | 16 | 19 | theorem extract_eq_nil_of_start_eq_end {a : Array α} :
a.extract i i = #[] := by |
refine extract_empty_of_stop_le_start a ?h
exact Nat.le_refl i
| [
" a.extract i i = #[]",
" i ≤ i"
] | [] |
import Mathlib.RingTheory.Polynomial.Cyclotomic.Roots
import Mathlib.Data.ZMod.Algebra
#align_import ring_theory.polynomial.cyclotomic.expand from "leanprover-community/mathlib"@"0723536a0522d24fc2f159a096fb3304bef77472"
namespace Polynomial
@[simp]
theorem cyclotomic_expand_eq_cyclotomic_mul {p n : ℕ} (hp : Na... | Mathlib/RingTheory/Polynomial/Cyclotomic/Expand.lean | 100 | 110 | theorem cyclotomic_irreducible_pow_of_irreducible_pow {p : ℕ} (hp : Nat.Prime p) {R} [CommRing R]
[IsDomain R] {n m : ℕ} (hmn : m ≤ n) (h : Irreducible (cyclotomic (p ^ n) R)) :
Irreducible (cyclotomic (p ^ m) R) := by |
rcases m.eq_zero_or_pos with (rfl | hm)
· simpa using irreducible_X_sub_C (1 : R)
obtain ⟨k, rfl⟩ := Nat.exists_eq_add_of_le hmn
induction' k with k hk
· simpa using h
have : m + k ≠ 0 := (add_pos_of_pos_of_nonneg hm k.zero_le).ne'
rw [Nat.add_succ, pow_succ, ← cyclotomic_expand_eq_cyclotomic hp <| dvd_p... | [
" (expand R p) (cyclotomic n R) = cyclotomic (n * p) R * cyclotomic n R",
" (expand R p) (cyclotomic 0 R) = cyclotomic (0 * p) R * cyclotomic 0 R",
" (expand ℤ p) (cyclotomic n ℤ) = cyclotomic (n * p) ℤ * cyclotomic n ℤ",
" cyclotomic (n * p) ℤ * cyclotomic n ℤ ∣ (expand ℤ p) (cyclotomic n ℤ)",
" map (Int.c... | [
" (expand R p) (cyclotomic n R) = cyclotomic (n * p) R * cyclotomic n R",
" (expand R p) (cyclotomic 0 R) = cyclotomic (0 * p) R * cyclotomic 0 R",
" (expand ℤ p) (cyclotomic n ℤ) = cyclotomic (n * p) ℤ * cyclotomic n ℤ",
" cyclotomic (n * p) ℤ * cyclotomic n ℤ ∣ (expand ℤ p) (cyclotomic n ℤ)",
" map (Int.c... |
import Mathlib.Data.List.OfFn
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Infix
#align_import data.list.sort from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
open List.Perm
universe u
namespace List
section Sorted
variable {α : Type u} {r : α → α → Prop} {a : α} {l... | Mathlib/Data/List/Sort.lean | 80 | 85 | theorem Sorted.head!_le [Inhabited α] [Preorder α] {a : α} {l : List α} (h : Sorted (· < ·) l)
(ha : a ∈ l) : l.head! ≤ a := by |
rw [← List.cons_head!_tail (List.ne_nil_of_mem ha)] at h ha
cases ha
· exact le_rfl
· exact le_of_lt (rel_of_sorted_cons h a (by assumption))
| [
" Pairwise (fun x x_1 => x_1 ≠ x) l",
" Pairwise (fun x x_1 => x ≠ x_1) l",
" l.head! ≤ a",
" l.head! ≤ l.head!",
" a ∈ l.tail"
] | [
" Pairwise (fun x x_1 => x_1 ≠ x) l",
" Pairwise (fun x x_1 => x ≠ x_1) l"
] |
import Mathlib.MeasureTheory.Constructions.Pi
import Mathlib.MeasureTheory.Integral.Lebesgue
open scoped Classical ENNReal
open Set Function Equiv Finset
noncomputable section
namespace MeasureTheory
section LMarginal
variable {δ δ' : Type*} {π : δ → Type*} [∀ x, MeasurableSpace (π x)]
variable {μ : ∀ i, Measu... | Mathlib/MeasureTheory/Integral/Marginal.lean | 118 | 135 | theorem lmarginal_union (f : (∀ i, π i) → ℝ≥0∞) (hf : Measurable f)
(hst : Disjoint s t) : ∫⋯∫⁻_s ∪ t, f ∂μ = ∫⋯∫⁻_s, ∫⋯∫⁻_t, f ∂μ ∂μ := by |
ext1 x
let e := MeasurableEquiv.piFinsetUnion π hst
calc (∫⋯∫⁻_s ∪ t, f ∂μ) x
= ∫⁻ (y : (i : ↥(s ∪ t)) → π i), f (updateFinset x (s ∪ t) y)
∂.pi fun i' : ↥(s ∪ t) ↦ μ i' := rfl
_ = ∫⁻ (y : ((i : s) → π i) × ((j : t) → π j)), f (updateFinset x (s ∪ t) _)
∂(Measure.pi fun i : s ↦ μ i)... | [
" Measurable (∫⋯∫⁻_s, f ∂μ)",
" Measurable (uncurry fun x y => f (updateFinset x s y))",
" Measurable fun a => updateFinset a.1 s a.2",
" ∀ (a : δ), Measurable fun x => updateFinset x.1 s x.2 a",
" Measurable fun x => updateFinset x.1 s x.2 i",
" Measurable fun x => x.2 ⟨i, ⋯⟩",
" Measurable fun x => x.... | [
" Measurable (∫⋯∫⁻_s, f ∂μ)",
" Measurable (uncurry fun x y => f (updateFinset x s y))",
" Measurable fun a => updateFinset a.1 s a.2",
" ∀ (a : δ), Measurable fun x => updateFinset x.1 s x.2 a",
" Measurable fun x => updateFinset x.1 s x.2 i",
" Measurable fun x => x.2 ⟨i, ⋯⟩",
" Measurable fun x => x.... |
import Mathlib.Algebra.GroupPower.IterateHom
import Mathlib.Algebra.Polynomial.Eval
import Mathlib.GroupTheory.GroupAction.Ring
#align_import data.polynomial.derivative from "leanprover-community/mathlib"@"bbeb185db4ccee8ed07dc48449414ebfa39cb821"
noncomputable section
open Finset
open Polynomial
namespace Pol... | Mathlib/Algebra/Polynomial/Derivative.lean | 121 | 121 | theorem derivative_C {a : R} : derivative (C a) = 0 := by | simp [derivative_apply]
| [
" (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) (p + q) =\n (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) p + (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) q",
" ((p + q).sum fun n a => C (a * ↑n) * X ^ (n - 1)) =\n (p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) + q.sum fun n a => C (a * ↑... | [
" (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) (p + q) =\n (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) p + (fun p => p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) q",
" ((p + q).sum fun n a => C (a * ↑n) * X ^ (n - 1)) =\n (p.sum fun n a => C (a * ↑n) * X ^ (n - 1)) + q.sum fun n a => C (a * ↑... |
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 | 117 | 124 | theorem injective (φ : M ↪ₑ[L] N) : Function.Injective φ := by |
intro x y
have h :=
φ.map_formula ((var 0).equal (var 1) : L.Formula (Fin 2)) fun i => if i = 0 then x else y
rw [Formula.realize_equal, Formula.realize_equal] at h
simp only [Nat.one_ne_zero, Term.realize, Fin.one_eq_zero_iff, if_true, eq_self_iff_true,
Function.comp_apply, if_false] at h
exact h.1
| [
" 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.Analysis.Normed.Group.Hom
import Mathlib.Analysis.NormedSpace.Basic
import Mathlib.Analysis.NormedSpace.LinearIsometry
import Mathlib.Algebra.Star.SelfAdjoint
import Mathlib.Algebra.Star.Subalgebra
import Mathlib.Algebra.Star.Unitary
import Mathlib.Topology.Algebra.Module.Star
#align_import analysis.no... | Mathlib/Analysis/NormedSpace/Star/Basic.lean | 123 | 123 | theorem norm_star_mul_self' {x : E} : ‖x⋆ * x‖ = ‖x⋆‖ * ‖x‖ := by | rw [norm_star_mul_self, norm_star]
| [
" ‖x⋆ * x‖ = ‖x‖ * ‖x‖",
" ∀ (x : E), ‖x⋆‖ = ‖x‖",
" ‖x⋆‖ = ‖x‖",
" ‖x⋆‖ * ‖x⋆‖ = ‖x * x⋆‖",
" ‖x * x⋆‖ = ‖x‖ * ‖x‖",
" ‖x⋆⋆ * x⋆‖ = ‖x‖ * ‖x‖",
" ‖x⋆ * x‖ = ‖x⋆‖ * ‖x‖"
] | [
" ‖x⋆ * x‖ = ‖x‖ * ‖x‖",
" ∀ (x : E), ‖x⋆‖ = ‖x‖",
" ‖x⋆‖ = ‖x‖",
" ‖x⋆‖ * ‖x⋆‖ = ‖x * x⋆‖",
" ‖x * x⋆‖ = ‖x‖ * ‖x‖",
" ‖x⋆⋆ * x⋆‖ = ‖x‖ * ‖x‖"
] |
import Mathlib.Data.List.OfFn
import Mathlib.Data.List.Nodup
import Mathlib.Data.List.Infix
#align_import data.list.sort from "leanprover-community/mathlib"@"f694c7dead66f5d4c80f446c796a5aad14707f0e"
open List.Perm
universe u
namespace List
section Sorted
variable {α : Type u} {r : α → α → Prop} {a : α} {l... | Mathlib/Data/List/Sort.lean | 123 | 126 | theorem sublist_of_subperm_of_sorted [IsAntisymm α r] {l₁ l₂ : List α} (hp : l₁ <+~ l₂)
(hs₁ : l₁.Sorted r) (hs₂ : l₂.Sorted r) : l₁ <+ l₂ := by |
let ⟨_, h, h'⟩ := hp
rwa [← eq_of_perm_of_sorted h (hs₂.sublist h') hs₁]
| [
" Pairwise (fun x x_1 => x_1 ≠ x) l",
" Pairwise (fun x x_1 => x ≠ x_1) l",
" l.head! ≤ a",
" l.head! ≤ l.head!",
" a ∈ l.tail",
" a ≤ l.head!",
" l₁ = l₂",
" [] = l₂",
" a :: l₁ = l₂",
" a :: l₁ = u₂ ++ a :: v₂",
" u₂ ++ v₂ <+ u₂ ++ a :: v₂",
" a :: (u₂ ++ v₂) = u₂ ++ a :: v₂",
" a :: u₂ ++... | [
" Pairwise (fun x x_1 => x_1 ≠ x) l",
" Pairwise (fun x x_1 => x ≠ x_1) l",
" l.head! ≤ a",
" l.head! ≤ l.head!",
" a ∈ l.tail",
" a ≤ l.head!",
" l₁ = l₂",
" [] = l₂",
" a :: l₁ = l₂",
" a :: l₁ = u₂ ++ a :: v₂",
" u₂ ++ v₂ <+ u₂ ++ a :: v₂",
" a :: (u₂ ++ v₂) = u₂ ++ a :: v₂",
" a :: u₂ ++... |
import Mathlib.Data.Finset.Basic
import Mathlib.Data.Set.Lattice
#align_import data.set.constructions from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
variable {α : Type*} (S : Set (Set α))
structure FiniteInter : Prop where
univ_mem : Set.univ ∈ S
inter_mem : ∀ ⦃s⦄, s ∈ ... | Mathlib/Data/Set/Constructions.lean | 66 | 82 | theorem finiteInterClosure_insert {A : Set α} (cond : FiniteInter S) (P)
(H : P ∈ finiteInterClosure (insert A S)) : P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q := by |
induction' H with S h T1 T2 _ _ h1 h2
· cases h
· exact Or.inr ⟨Set.univ, cond.univ_mem, by simpa⟩
· exact Or.inl (by assumption)
· exact Or.inl cond.univ_mem
· rcases h1 with (h | ⟨Q, hQ, rfl⟩) <;> rcases h2 with (i | ⟨R, hR, rfl⟩)
· exact Or.inl (cond.inter_mem h i)
· exact
Or.inr ⟨T1... | [
" ↑F ⊆ S → ⋂₀ ↑F ∈ S",
" ⋂₀ ↑∅ ∈ S",
" ∀ ⦃a : Set α⦄ {s : Finset (Set α)}, a ∉ s → (↑s ⊆ S → ⋂₀ ↑s ∈ S) → ↑(insert a s) ⊆ S → ⋂₀ ↑(insert a s) ∈ S",
" ⋂₀ ↑(insert a s) ∈ S",
" a ∩ ⋂₀ ↑s ∈ S",
" P ∈ S ∨ ∃ Q ∈ S, P = A ∩ Q",
" S ∈ S✝ ∨ ∃ Q ∈ S✝, S = A ∩ Q",
" S = A ∩ Set.univ",
" S ∈ S✝",
" Set.univ... | [
" ↑F ⊆ S → ⋂₀ ↑F ∈ S",
" ⋂₀ ↑∅ ∈ S",
" ∀ ⦃a : Set α⦄ {s : Finset (Set α)}, a ∉ s → (↑s ⊆ S → ⋂₀ ↑s ∈ S) → ↑(insert a s) ⊆ S → ⋂₀ ↑(insert a s) ∈ S",
" ⋂₀ ↑(insert a s) ∈ S",
" a ∩ ⋂₀ ↑s ∈ S"
] |
import Mathlib.Data.List.Cycle
import Mathlib.GroupTheory.Perm.Cycle.Type
import Mathlib.GroupTheory.Perm.List
#align_import group_theory.perm.cycle.concrete from "leanprover-community/mathlib"@"00638177efd1b2534fc5269363ebf42a7871df9a"
open Equiv Equiv.Perm List
variable {α : Type*}
namespace Equiv.Perm
secti... | Mathlib/GroupTheory/Perm/Cycle/Concrete.lean | 221 | 221 | theorem toList_one : toList (1 : Perm α) x = [] := by | simp [toList, cycleOf_one]
| [
" toList 1 x = []"
] | [] |
import Mathlib.Order.Interval.Set.Monotone
import Mathlib.Probability.Process.HittingTime
import Mathlib.Probability.Martingale.Basic
import Mathlib.Tactic.AdaptationNote
#align_import probability.martingale.upcrossing from "leanprover-community/mathlib"@"2c1d8ca2812b64f88992a5294ea3dba144755cd1"
open Topological... | Mathlib/Probability/Martingale/Upcrossing.lean | 168 | 170 | theorem upperCrossingTime_succ : upperCrossingTime a b f N (n + 1) ω =
hitting f (Set.Ici b) (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) N ω := by |
rw [upperCrossingTime]
| [
" upperCrossingTime a b f N (n + 1) ω =\n hitting f (Set.Ici b) (lowerCrossingTimeAux a f (upperCrossingTime a b f N n ω) N ω) N ω"
] | [] |
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 | 106 | 112 | theorem coe_splitUpper : (splitUpper I i x : Set (ι → ℝ)) = ↑I ∩ { y | x < y i } := by |
rw [splitUpper, coe_mk']
ext y
simp only [mem_univ_pi, mem_Ioc, mem_inter_iff, mem_coe, mem_setOf_eq, forall_and,
forall_update_iff I.lower fun j z => z < y j, max_lt_iff, and_assoc (a := x < y i),
and_forall_ne (p := fun j => lower I j < y j) i, mem_def]
exact and_comm
| [
" ↑(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.Data.Int.Defs
import Mathlib.Data.Nat.Defs
import Mathlib.Tactic.Common
#align_import data.int.sqrt from "leanprover-community/mathlib"@"ba2245edf0c8bb155f1569fd9b9492a9b384cde6"
namespace Int
-- @[pp_nodot] porting note: unknown attribute
def sqrt (z : ℤ) : ℤ :=
Nat.sqrt <| Int.toNat z
#align ... | Mathlib/Data/Int/Sqrt.lean | 30 | 31 | theorem sqrt_eq (n : ℤ) : sqrt (n * n) = n.natAbs := by |
rw [sqrt, ← natAbs_mul_self, toNat_natCast, Nat.sqrt_eq]
| [
" (n * n).sqrt = ↑n.natAbs"
] | [] |
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Dynamics.FixedPoints.Basic
open Finset Function
section AddCommMonoid
variable {α M : Type*} [AddCommMonoid M]
def birkhoffSum (f : α → α) (g : α → M) (n : ℕ) (x : α) : M := ∑ k ∈ range n, g (f^[k] x)
theorem birkhoffSum_zero (f : α → α) (g : α → ... | Mathlib/Dynamics/BirkhoffSum/Basic.lean | 55 | 57 | theorem Function.IsFixedPt.birkhoffSum_eq {f : α → α} {x : α} (h : IsFixedPt f x) (g : α → M)
(n : ℕ) : birkhoffSum f g n x = n • g x := by |
simp [birkhoffSum, (h.iterate _).eq]
| [
" birkhoffSum f g (m + n) x = birkhoffSum f g m x + birkhoffSum f g n (f^[m] x)",
" birkhoffSum f g n x = n • g x"
] | [
" birkhoffSum f g (m + n) x = birkhoffSum f g m x + birkhoffSum f g n (f^[m] x)"
] |
import Mathlib.Order.CompleteLattice
import Mathlib.Order.Cover
import Mathlib.Order.Iterate
import Mathlib.Order.WellFounded
#align_import order.succ_pred.basic from "leanprover-community/mathlib"@"0111834459f5d7400215223ea95ae38a1265a907"
open Function OrderDual Set
variable {α β : Type*}
@[ext]
class SuccOr... | Mathlib/Order/SuccPred/Basic.lean | 279 | 281 | theorem succ_lt_succ_iff_of_not_isMax (ha : ¬IsMax a) (hb : ¬IsMax b) :
succ a < succ b ↔ a < b := by |
rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
| [
" ∀ (a : αᵒᵈ), (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) a ≤ a",
" IsMin a✝",
" ∀ {a b : αᵒᵈ}, a < b → a ≤ (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) b",
" a ≤ (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) b",
" ∀ (a : αᵒᵈ), a ≤ (⇑toDual ∘ PredOrder.pred ∘ ⇑ofDual) a",
" IsMax a✝",
" ∀ {a b : αᵒᵈ}, a < b → (⇑toDual ∘ PredO... | [
" ∀ (a : αᵒᵈ), (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) a ≤ a",
" IsMin a✝",
" ∀ {a b : αᵒᵈ}, a < b → a ≤ (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) b",
" a ≤ (⇑toDual ∘ SuccOrder.succ ∘ ⇑ofDual) b",
" ∀ (a : αᵒᵈ), a ≤ (⇑toDual ∘ PredOrder.pred ∘ ⇑ofDual) a",
" IsMax a✝",
" ∀ {a b : αᵒᵈ}, a < b → (⇑toDual ∘ PredO... |
import Mathlib.Analysis.Calculus.ContDiff.Basic
import Mathlib.Analysis.NormedSpace.FiniteDimension
#align_import analysis.calculus.cont_diff from "leanprover-community/mathlib"@"3bce8d800a6f2b8f63fe1e588fd76a9ff4adcebe"
noncomputable section
universe uD uE uF uG
variable {𝕜 : Type*} [NontriviallyNormedField ... | Mathlib/Analysis/Calculus/ContDiff/FiniteDimension.lean | 71 | 75 | theorem contDiffOn_succ_iff_fderiv_apply [FiniteDimensional 𝕜 E] {n : ℕ} {f : E → F} {s : Set E}
(hs : UniqueDiffOn 𝕜 s) :
ContDiffOn 𝕜 (n + 1 : ℕ) f s ↔
DifferentiableOn 𝕜 f s ∧ ∀ y, ContDiffOn 𝕜 n (fun x => fderivWithin 𝕜 f s x y) s := by |
rw [contDiffOn_succ_iff_fderivWithin hs, contDiffOn_clm_apply]
| [
" ContDiffOn 𝕜 n f s ↔ ∀ (y : F), ContDiffOn 𝕜 n (fun x => (f x) y) s",
" ContDiffOn 𝕜 n f s",
" ContDiffOn 𝕜 n ((⇑e₂.symm ∘ ⇑e₂) ∘ f) s",
" ContDiff 𝕜 n f ↔ ∀ (y : F), ContDiff 𝕜 n fun x => (f x) y",
" ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ∀ (y : E), ContDiff 𝕜 ↑n fun x => (fderiv 𝕜 f x)... | [
" ContDiffOn 𝕜 n f s ↔ ∀ (y : F), ContDiffOn 𝕜 n (fun x => (f x) y) s",
" ContDiffOn 𝕜 n f s",
" ContDiffOn 𝕜 n ((⇑e₂.symm ∘ ⇑e₂) ∘ f) s",
" ContDiff 𝕜 n f ↔ ∀ (y : F), ContDiff 𝕜 n fun x => (f x) y",
" ContDiff 𝕜 (↑(n + 1)) f ↔ Differentiable 𝕜 f ∧ ∀ (y : E), ContDiff 𝕜 ↑n fun x => (fderiv 𝕜 f x)... |
import Mathlib.Analysis.Complex.Basic
import Mathlib.Topology.FiberBundle.IsHomeomorphicTrivialBundle
#align_import analysis.complex.re_im_topology from "leanprover-community/mathlib"@"468b141b14016d54b479eb7a0fff1e360b7e3cf6"
open Set
noncomputable section
namespace Complex
theorem isHomeomorphicTrivialFiber... | Mathlib/Analysis/Complex/ReImTopology.lean | 104 | 105 | theorem interior_setOf_le_re (a : ℝ) : interior { z : ℂ | a ≤ z.re } = { z | a < z.re } := by |
simpa only [interior_Ici] using interior_preimage_re (Ici a)
| [
" interior {z | z.re ≤ a} = {z | z.re < a}",
" interior {z | z.im ≤ a} = {z | z.im < a}",
" interior {z | a ≤ z.re} = {z | a < z.re}"
] | [
" interior {z | z.re ≤ a} = {z | z.re < a}",
" interior {z | z.im ≤ a} = {z | z.im < a}"
] |
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 | 197 | 199 | theorem self_mem_span_image [Nontrivial R] {i : ι} {s : Set ι} :
b i ∈ span R (b '' s) ↔ i ∈ s := by |
simp [mem_span_image, Finsupp.support_single_ne_zero]
| [
" { 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.AlgebraicGeometry.AffineScheme
import Mathlib.RingTheory.Nilpotent.Lemmas
import Mathlib.Topology.Sheaves.SheafCondition.Sites
import Mathlib.Algebra.Category.Ring.Constructions
import Mathlib.RingTheory.LocalProperties
#align_import algebraic_geometry.properties from "leanprover-community/mathlib"@"88... | Mathlib/AlgebraicGeometry/Properties.lean | 105 | 112 | theorem affine_isReduced_iff (R : CommRingCat) :
IsReduced (Scheme.Spec.obj <| op R) ↔ _root_.IsReduced R := by |
refine ⟨?_, fun h => inferInstance⟩
intro h
have : _root_.IsReduced
(LocallyRingedSpace.Γ.obj (op <| Spec.toLocallyRingedSpace.obj <| op R)) := by
change _root_.IsReduced ((Scheme.Spec.obj <| op R).presheaf.obj <| op ⊤); infer_instance
exact isReduced_of_injective (toSpecΓ R) (asIso <| toSpecΓ R).com... | [
" T0Space ↑↑X.toPresheafedSpace",
" ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s",
" QuasiSober ↑↑X.toPresheafedSpace",
" ∀ (s : ↑(Set.range fun x => Set.range ⇑(X.affineCover.map x).val.base)), IsOpen ↑s",
" IsOpen ↑⟨(fun x => Set.range ⇑(X.affineCover.map x).val.base) i, ⋯⟩",
" ∀ (s : ↑(Set.range fun x => Set.ran... | [
" T0Space ↑↑X.toPresheafedSpace",
" ∃ s, x ∈ s ∧ IsOpen s ∧ T0Space ↑s",
" QuasiSober ↑↑X.toPresheafedSpace",
" ∀ (s : ↑(Set.range fun x => Set.range ⇑(X.affineCover.map x).val.base)), IsOpen ↑s",
" IsOpen ↑⟨(fun x => Set.range ⇑(X.affineCover.map x).val.base) i, ⋯⟩",
" ∀ (s : ↑(Set.range fun x => Set.ran... |
import Mathlib.Algebra.Associated
import Mathlib.Algebra.BigOperators.Group.Finset
import Mathlib.Algebra.SMulWithZero
import Mathlib.Data.Nat.PartENat
import Mathlib.Tactic.Linarith
#align_import ring_theory.multiplicity from "leanprover-community/mathlib"@"e8638a0fcaf73e4500469f368ef9494e495099b3"
variable {α β... | Mathlib/RingTheory/Multiplicity.lean | 65 | 73 | theorem Int.natCast_multiplicity (a b : ℕ) : multiplicity (a : ℤ) (b : ℤ) = multiplicity a b := by |
apply Part.ext'
· rw [← @finite_iff_dom ℕ, @finite_def ℕ, ← @finite_iff_dom ℤ, @finite_def ℤ]
norm_cast
· intro h1 h2
apply _root_.le_antisymm <;>
· apply Nat.find_mono
norm_cast
simp
| [
" multiplicity ↑a ↑b = multiplicity a b",
" (multiplicity ↑a ↑b).Dom ↔ (multiplicity a b).Dom",
" (∃ n, ¬↑a ^ (n + 1) ∣ ↑b) ↔ ∃ n, ¬a ^ (n + 1) ∣ b",
" ∀ (h₁ : (multiplicity ↑a ↑b).Dom) (h₂ : (multiplicity a b).Dom),\n (multiplicity ↑a ↑b).get h₁ = (multiplicity a b).get h₂",
" (multiplicity ↑a ↑b).get h... | [] |
import Mathlib.Analysis.SpecialFunctions.Pow.Asymptotics
import Mathlib.NumberTheory.Liouville.Basic
import Mathlib.Topology.Instances.Irrational
#align_import number_theory.liouville.liouville_with from "leanprover-community/mathlib"@"0b9eaaa7686280fad8cce467f5c3c57ee6ce77f8"
open Filter Metric Real Set
open sc... | Mathlib/NumberTheory/Liouville/LiouvilleWith.lean | 54 | 66 | theorem liouvilleWith_one (x : ℝ) : LiouvilleWith 1 x := by |
use 2
refine ((eventually_gt_atTop 0).mono fun n hn => ?_).frequently
have hn' : (0 : ℝ) < n := by simpa
have : x < ↑(⌊x * ↑n⌋ + 1) / ↑n := by
rw [lt_div_iff hn', Int.cast_add, Int.cast_one];
exact Int.lt_floor_add_one _
refine ⟨⌊x * n⌋ + 1, this.ne, ?_⟩
rw [abs_sub_comm, abs_of_pos (sub_pos.2 this... | [
" LiouvilleWith 1 x",
" ∃ᶠ (n : ℕ) in atTop, ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < 2 / ↑n ^ 1",
" ∃ m, x ≠ ↑m / ↑n ∧ |x - ↑m / ↑n| < 2 / ↑n ^ 1",
" 0 < ↑n",
" x < ↑(⌊x * ↑n⌋ + 1) / ↑n",
" x * ↑n < ↑⌊x * ↑n⌋ + 1",
" |x - ↑(⌊x * ↑n⌋ + 1) / ↑n| < 2 / ↑n ^ 1",
" ↑(⌊x * ↑n⌋ + 1) / ↑n < (x * ↑n + 2) / ↑n",
"... | [] |
import Mathlib.Probability.Martingale.Convergence
import Mathlib.Probability.Martingale.OptionalStopping
import Mathlib.Probability.Martingale.Centering
#align_import probability.martingale.borel_cantelli from "leanprover-community/mathlib"@"2196ab363eb097c008d4497125e0dde23fb36db2"
open Filter
open scoped NNRea... | Mathlib/Probability/Martingale/BorelCantelli.lean | 93 | 98 | theorem stoppedValue_stoppedValue_leastGE (f : ℕ → Ω → ℝ) (π : Ω → ℕ) (r : ℝ) {n : ℕ}
(hπn : ∀ ω, π ω ≤ n) : stoppedValue (fun i => stoppedValue f (leastGE f r i)) π =
stoppedValue (stoppedProcess f (leastGE f r n)) π := by |
ext1 ω
simp (config := { unfoldPartialApp := true }) only [stoppedProcess, stoppedValue]
rw [leastGE_eq_min _ _ _ hπn]
| [
" leastGE f r (π ω) ω = min (π ω) (leastGE f r n ω)",
" min (π ω) (leastGE f r n ω) ≤ leastGE f r (π ω) ω",
" π ω ≤ hitting f (Set.Ici r) 0 (π ω) ω",
" leastGE f r n ω = hitting f (Set.Ici r) 0 (π ω) ω",
" ∃ j ∈ Set.Icc 0 (π ω), f j ω ∈ Set.Ici r",
" stoppedValue (fun i => stoppedValue f (leastGE f r i)) ... | [
" leastGE f r (π ω) ω = min (π ω) (leastGE f r n ω)",
" min (π ω) (leastGE f r n ω) ≤ leastGE f r (π ω) ω",
" π ω ≤ hitting f (Set.Ici r) 0 (π ω) ω",
" leastGE f r n ω = hitting f (Set.Ici r) 0 (π ω) ω",
" ∃ j ∈ Set.Icc 0 (π ω), f j ω ∈ Set.Ici r"
] |
import Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
import Mathlib.Dynamics.Ergodic.MeasurePreserving
import Mathlib.Combinatorics.Pigeonhole
#align_import dynamics.ergodic.conservative from "leanprover-community/mathlib"@"bf6a01357ff5684b1ebcd0f1a13be314fc82c0bf"
noncomputable section
open scoped Classi... | Mathlib/Dynamics/Ergodic/Conservative.lean | 83 | 106 | theorem frequently_measure_inter_ne_zero (hf : Conservative f μ) (hs : MeasurableSet s)
(h0 : μ s ≠ 0) : ∃ᶠ m in atTop, μ (s ∩ f^[m] ⁻¹' s) ≠ 0 := by |
by_contra H
simp only [not_frequently, eventually_atTop, Ne, Classical.not_not] at H
rcases H with ⟨N, hN⟩
induction' N with N ihN
· apply h0
simpa using hN 0 le_rfl
rw [imp_false] at ihN
push_neg at ihN
rcases ihN with ⟨n, hn, hμn⟩
set T := s ∩ ⋃ n ≥ N + 1, f^[n] ⁻¹' s
have hT : MeasurableSet ... | [
" ∃ᶠ (m : ℕ) in atTop, μ (s ∩ f^[m] ⁻¹' s) ≠ 0",
" False",
" μ s = 0",
" μ T = 0",
" T = ⋃ i ∈ fun i => (N + 1).le i, s ∩ f^[i] ⁻¹' s",
" T = s ∩ ⋃ i ∈ fun i => (N + 1).le i, f^[i] ⁻¹' s",
" μ ((s ∩ f^[n] ⁻¹' s) \\ T) ≠ 0",
" n + m ≥ N + 1",
" x ∈ f^[n + m] ⁻¹' s"
] | [] |
import Mathlib.Algebra.Regular.Basic
import Mathlib.LinearAlgebra.Matrix.MvPolynomial
import Mathlib.LinearAlgebra.Matrix.Polynomial
import Mathlib.RingTheory.Polynomial.Basic
#align_import linear_algebra.matrix.adjugate from "leanprover-community/mathlib"@"a99f85220eaf38f14f94e04699943e185a5e1d1a"
namespace Matr... | Mathlib/LinearAlgebra/Matrix/Adjugate.lean | 106 | 116 | theorem cramer_transpose_row_self (i : n) : Aᵀ.cramer (A i) = Pi.single i A.det := by |
ext j
rw [cramer_apply, Pi.single_apply]
split_ifs with h
· -- i = j: this entry should be `A.det`
subst h
simp only [updateColumn_transpose, det_transpose, updateRow_eq_self]
· -- i ≠ j: this entry should be 0
rw [updateColumn_transpose, det_transpose]
apply det_zero_of_row_eq h
rw [upda... | [
" IsLinearMap α A.cramerMap",
" ∀ (x y : n → α), A.cramerMap (x + y) = A.cramerMap x + A.cramerMap y",
" ∀ (c : α) (x : n → α), A.cramerMap (c • x) = c • A.cramerMap x",
" A.cramerMap (x✝ + y✝) = A.cramerMap x✝ + A.cramerMap y✝",
" A.cramerMap (c✝ • x✝) = c✝ • A.cramerMap x✝",
" A.cramerMap (x✝ + y✝) i = ... | [
" IsLinearMap α A.cramerMap",
" ∀ (x y : n → α), A.cramerMap (x + y) = A.cramerMap x + A.cramerMap y",
" ∀ (c : α) (x : n → α), A.cramerMap (c • x) = c • A.cramerMap x",
" A.cramerMap (x✝ + y✝) = A.cramerMap x✝ + A.cramerMap y✝",
" A.cramerMap (c✝ • x✝) = c✝ • A.cramerMap x✝",
" A.cramerMap (x✝ + y✝) i = ... |
import Mathlib.Data.Real.Basic
#align_import data.real.sign from "leanprover-community/mathlib"@"9003f28797c0664a49e4179487267c494477d853"
namespace Real
noncomputable def sign (r : ℝ) : ℝ :=
if r < 0 then -1 else if 0 < r then 1 else 0
#align real.sign Real.sign
| Mathlib/Data/Real/Sign.lean | 36 | 36 | theorem sign_of_neg {r : ℝ} (hr : r < 0) : sign r = -1 := by | rw [sign, if_pos hr]
| [
" r.sign = -1"
] | [] |
import Mathlib.Algebra.Order.Monoid.Unbundled.Basic
#align_import algebra.order.monoid.min_max from "leanprover-community/mathlib"@"de87d5053a9fe5cbde723172c0fb7e27e7436473"
open Function
variable {α β : Type*}
section CovariantClassMulLe
variable [LinearOrder α]
section Mul
variable [Mul α]
@[to_additive... | Mathlib/Algebra/Order/Monoid/Unbundled/MinMax.lean | 90 | 94 | theorem lt_or_lt_of_mul_lt_mul [CovariantClass α α (· * ·) (· ≤ ·)]
[CovariantClass α α (Function.swap (· * ·)) (· ≤ ·)] {a₁ a₂ b₁ b₂ : α} :
a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂ := by |
contrapose!
exact fun h => mul_le_mul' h.1 h.2
| [
" a₁ * b₁ < a₂ * b₂ → a₁ < a₂ ∨ b₁ < b₂",
" a₂ ≤ a₁ ∧ b₂ ≤ b₁ → a₂ * b₂ ≤ a₁ * b₁"
] | [] |
import Mathlib.Algebra.IsPrimePow
import Mathlib.Data.Nat.Factorization.Basic
#align_import data.nat.factorization.prime_pow from "leanprover-community/mathlib"@"6ca1a09bc9aa75824bf97388c9e3b441fc4ccf3f"
variable {R : Type*} [CommMonoidWithZero R] (n p : R) (k : ℕ)
theorem IsPrimePow.minFac_pow_factorization_eq ... | Mathlib/Data/Nat/Factorization/PrimePow.lean | 76 | 84 | theorem exists_ord_compl_eq_one_iff_isPrimePow {n : ℕ} (hn : n ≠ 1) :
IsPrimePow n ↔ ∃ p : ℕ, p.Prime ∧ ord_compl[p] n = 1 := by |
refine ⟨fun h => IsPrimePow.exists_ord_compl_eq_one h, fun h => ?_⟩
rcases h with ⟨p, pp, h⟩
rw [isPrimePow_nat_iff]
rw [← Nat.eq_of_dvd_of_div_eq_one (Nat.ord_proj_dvd n p) h] at hn ⊢
refine ⟨p, n.factorization p, pp, ?_, by simp⟩
contrapose! hn
simp [Nat.le_zero.1 hn]
| [
" n.minFac ^ n.factorization n.minFac = n",
" (p ^ k).minFac ^ (p ^ k).factorization (p ^ k).minFac = p ^ k",
" IsPrimePow n",
" IsPrimePow 0",
" 0 < n.factorization n.minFac",
" IsPrimePow n ↔ ∃ p k, 0 < k ∧ n.factorization = Finsupp.single p k",
" (∃ p k, p.Prime ∧ 0 < k ∧ p ^ k = n) ↔ ∃ p k, 0 < k ∧ ... | [
" n.minFac ^ n.factorization n.minFac = n",
" (p ^ k).minFac ^ (p ^ k).factorization (p ^ k).minFac = p ^ k",
" IsPrimePow n",
" IsPrimePow 0",
" 0 < n.factorization n.minFac",
" IsPrimePow n ↔ ∃ p k, 0 < k ∧ n.factorization = Finsupp.single p k",
" (∃ p k, p.Prime ∧ 0 < k ∧ p ^ k = n) ↔ ∃ p k, 0 < k ∧ ... |
import Mathlib.Algebra.TrivSqZeroExt
#align_import algebra.dual_number from "leanprover-community/mathlib"@"b8d2eaa69d69ce8f03179a5cda774fc0cde984e4"
variable {R A B : Type*}
abbrev DualNumber (R : Type*) : Type _ :=
TrivSqZeroExt R R
#align dual_number DualNumber
def DualNumber.eps [Zero R] [One R] : DualN... | Mathlib/Algebra/DualNumber.lean | 96 | 97 | theorem commute_eps_left [Semiring R] (x : DualNumber R) : Commute ε x := by |
ext <;> simp
| [
" Commute ε x",
" fst (ε * x) = fst (x * ε)",
" snd (ε * x) = snd (x * ε)"
] | [] |
import Mathlib.Data.Vector.Basic
#align_import data.vector.mem from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
namespace Vector
variable {α β : Type*} {n : ℕ} (a a' : α)
@[simp]
theorem get_mem (i : Fin n) (v : Vector α n) : v.get i ∈ v.toList := by
rw [get_eq_get]
exact List.... | Mathlib/Data/Vector/Mem.lean | 38 | 41 | theorem not_mem_nil : a ∉ (Vector.nil : Vector α 0).toList := by |
unfold Vector.nil
dsimp
simp
| [
" v.get i ∈ v.toList",
" v.toList.get (Fin.cast ⋯ i) ∈ v.toList",
" a ∈ v.toList ↔ ∃ i, v.get i = a",
" (∃ i, ∃ (h : i < v.toList.length), v.toList.get ⟨i, h⟩ = a) ↔ ∃ i, ∃ (h : i < n), v.toList.get (Fin.cast ⋯ ⟨i, h⟩) = a",
" i < n",
" i < v.toList.length",
" a ∉ nil.toList",
" a ∉ toList ⟨[], ⋯⟩",
... | [
" v.get i ∈ v.toList",
" v.toList.get (Fin.cast ⋯ i) ∈ v.toList",
" a ∈ v.toList ↔ ∃ i, v.get i = a",
" (∃ i, ∃ (h : i < v.toList.length), v.toList.get ⟨i, h⟩ = a) ↔ ∃ i, ∃ (h : i < n), v.toList.get (Fin.cast ⋯ ⟨i, h⟩) = a",
" i < n",
" i < v.toList.length"
] |
import Mathlib.Algebra.BigOperators.Ring
import Mathlib.Data.Fintype.Basic
import Mathlib.Data.Int.GCD
import Mathlib.RingTheory.Coprime.Basic
#align_import ring_theory.coprime.lemmas from "leanprover-community/mathlib"@"509de852e1de55e1efa8eacfa11df0823f26f226"
universe u v
section RelPrime
variable {α I} [Comm... | Mathlib/RingTheory/Coprime/Lemmas.lean | 299 | 301 | theorem pow_right (H : IsRelPrime x y) : IsRelPrime x (y ^ n) := by |
rw [← Finset.card_range n, ← Finset.prod_const]
exact IsRelPrime.prod_right fun _ _ ↦ H
| [
" (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x",
" IsRelPrime (∏ i ∈ insert b t, s i) x",
" IsRelPrime (s b * ∏ x ∈ t, s x) x",
" (∀ i ∈ t, IsRelPrime x (s i)) → IsRelPrime x (∏ i ∈ t, s i)",
" IsRelPrime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsRelPrime (s i) x",
" x✝ ∈ ∅ → IsRelPrime (s x✝) x",
" ... | [
" (∀ i ∈ t, IsRelPrime (s i) x) → IsRelPrime (∏ i ∈ t, s i) x",
" IsRelPrime (∏ i ∈ insert b t, s i) x",
" IsRelPrime (s b * ∏ x ∈ t, s x) x",
" (∀ i ∈ t, IsRelPrime x (s i)) → IsRelPrime x (∏ i ∈ t, s i)",
" IsRelPrime (∏ i ∈ t, s i) x ↔ ∀ i ∈ t, IsRelPrime (s i) x",
" x✝ ∈ ∅ → IsRelPrime (s x✝) x",
" ... |
import Mathlib.Data.Int.GCD
import Mathlib.Tactic.NormNum
namespace Tactic
namespace NormNum
theorem int_gcd_helper' {d : ℕ} {x y : ℤ} (a b : ℤ) (h₁ : (d : ℤ) ∣ x) (h₂ : (d : ℤ) ∣ y)
(h₃ : x * a + y * b = d) : Int.gcd x y = d := by
refine Nat.dvd_antisymm ?_ (Int.natCast_dvd_natCast.1 (Int.dvd_gcd h₁ h₂))
... | Mathlib/Tactic/NormNum/GCD.lean | 36 | 43 | theorem nat_gcd_helper_2 (d x y a b : ℕ) (hu : x % d = 0) (hv : y % d = 0)
(h : x * a = y * b + d) : Nat.gcd x y = d := by |
rw [← Int.gcd_natCast_natCast]
apply int_gcd_helper' a (-b)
(Int.natCast_dvd_natCast.mpr (Nat.dvd_of_mod_eq_zero hu))
(Int.natCast_dvd_natCast.mpr (Nat.dvd_of_mod_eq_zero hv))
rw [mul_neg, ← sub_eq_add_neg, sub_eq_iff_eq_add']
exact mod_cast h
| [
" x.gcd y = d",
" x.gcd y ∣ d",
" ↑(x.gcd y) ∣ x * a + y * b",
" ↑(x.gcd y) ∣ x * a",
" ↑(x.gcd y) ∣ y * b",
" (↑x).gcd ↑y = d",
" ↑x * ↑a + ↑y * -↑b = ↑d",
" ↑x * ↑a = ↑y * ↑b + ↑d"
] | [
" x.gcd y = d",
" x.gcd y ∣ d",
" ↑(x.gcd y) ∣ x * a + y * b",
" ↑(x.gcd y) ∣ x * a",
" ↑(x.gcd y) ∣ y * b"
] |
import Mathlib.AlgebraicTopology.DoldKan.EquivalenceAdditive
import Mathlib.AlgebraicTopology.DoldKan.Compatibility
import Mathlib.CategoryTheory.Idempotents.SimplicialObject
#align_import algebraic_topology.dold_kan.equivalence_pseudoabelian from "leanprover-community/mathlib"@"32a7e535287f9c73f2e4d2aef306a39190f0b5... | Mathlib/AlgebraicTopology/DoldKan/EquivalencePseudoabelian.lean | 108 | 114 | theorem hη :
Compatibility.τ₀ =
Compatibility.τ₁ isoN₁ isoΓ₀
(N₁Γ₀ : Γ ⋙ N₁ ≅ (toKaroubiEquivalence (ChainComplex C ℕ)).functor) := by |
ext K : 3
simp only [Compatibility.τ₀_hom_app, Compatibility.τ₁_hom_app]
exact (N₂Γ₂_compatible_with_N₁Γ₀ K).trans (by simp )
| [
" (N₂.map (isoΓ₀.hom.app X)).f = PInfty",
" (N₂.map (isoΓ₀.hom.app X)).f.f i✝ = PInfty.f i✝",
" Compatibility.τ₀ = Compatibility.τ₁ isoN₁ isoΓ₀ N₁Γ₀",
" Compatibility.τ₀.hom.app K = (Compatibility.τ₁ isoN₁ isoΓ₀ N₁Γ₀).hom.app K",
" Preadditive.DoldKan.equivalence.counitIso.hom.app ((toKaroubiEquivalence (Ch... | [
" (N₂.map (isoΓ₀.hom.app X)).f = PInfty",
" (N₂.map (isoΓ₀.hom.app X)).f.f i✝ = PInfty.f i✝"
] |
import Mathlib.Algebra.Group.Equiv.Basic
import Mathlib.Algebra.Group.Aut
import Mathlib.Data.ZMod.Defs
import Mathlib.Tactic.Ring
#align_import algebra.quandle from "leanprover-community/mathlib"@"28aa996fc6fb4317f0083c4e6daf79878d81be33"
open MulOpposite
universe u v
class Shelf (α : Type u) where
act : ... | Mathlib/Algebra/Quandle.lean | 225 | 229 | theorem left_cancel (x : R) {y y' : R} : x ◃ y = x ◃ y' ↔ y = y' := by |
constructor
· apply (act' x).injective
rintro rfl
rfl
| [
" x ◃ y = x ◃ y' ↔ y = y'",
" x ◃ y = x ◃ y' → y = y'",
" y = y' → x ◃ y = x ◃ y'",
" x ◃ y = x ◃ y"
] | [] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.