name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Nat.sub_max_sub_left | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max (a - b) (a - c) = a - min b c |
UInt64.toUInt8_eq | Init.Data.UInt.Lemmas | ∀ (a b : UInt64), a.toUInt8 = b.toUInt8 ↔ a % 256 = b % 256 |
_private.Init.Data.Nat.ToString.0.Nat.toDigitsCore_eq_of_lt_fuel._simp_1_4 | Init.Data.Nat.ToString | ∀ {a b : ℕ}, (a / b = 0) = (b = 0 ∨ a < b) |
Std.DTreeMap.Internal.Impl.Const.compare_maxKey!_modify_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited α],
t.WF → ∀ {k : α} {f : β → β}, compare (Std.DTreeMap.Internal.Impl.Const.modify k f t).maxKey! t.maxKey! = Ordering.eq |
Cardinal.lift_inj._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{u}}, (Cardinal.lift.{v, u} a = Cardinal.lift.{v, u} b) = (a = b) |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_3 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (f : (↑R)ᵒᵖ), (CategoryTheory.inducedFunctor PrimeSpectrum.basicOpen).obj (Opposite.unop f) ≤ ⊤ |
Subtype.exists | Init.Data.Subtype.Basic | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) ↔ ∃ a, ∃ (b : p a), q ⟨a, b⟩ |
BoxIntegral.unitPartition.prepartition._proof_1 | Mathlib.Analysis.BoxIntegral.UnitPartition | ∀ {ι : Type u_1} (n : ℕ) [inst : NeZero n] [inst_1 : Fintype ι] (B x : BoxIntegral.Box ι),
x ∈ Finset.image (fun ν => BoxIntegral.unitPartition.box n ν) (BoxIntegral.unitPartition.admissibleIndex n B) → x ≤ B |
supClosure._proof_1 | Mathlib.Order.SupClosed | ∀ {α : Type u_1} [inst : SemilatticeSup α] (s : Set α), ∀ a ∈ s, ↑{a} ⊆ s ∧ {a}.sup' ⋯ id = a |
DistribLattice.noConfusionType | Mathlib.Order.Lattice | Sort u → {α : Type u_1} → DistribLattice α → {α' : Type u_1} → DistribLattice α' → Sort u |
Real.tendsto_integral_gaussian_smul' | Mathlib.Analysis.Fourier.Inversion | ∀ {V : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V]
[inst_2 : MeasurableSpace V] [inst_3 : BorelSpace V] [inst_4 : FiniteDimensional ℝ V] [inst_5 : NormedAddCommGroup E]
[inst_6 : NormedSpace ℂ E] {f : V → E} [CompleteSpace E],
MeasureTheory.Integrable f MeasureTheory.volume →
∀ {v : V},
ContinuousAt f v →
Filter.Tendsto
(fun c =>
∫ (w : V),
((↑Real.pi * ↑c) ^ (↑(Module.finrank ℝ V) / 2) * Complex.exp (-↑Real.pi ^ 2 * ↑c * ↑‖v - w‖ ^ 2)) • f w)
Filter.atTop (nhds (f v)) |
AffineBasis.instAddAction | Mathlib.LinearAlgebra.AffineSpace.Basis | {ι : Type u_1} →
{k : Type u_5} →
{V : Type u_6} →
{P : Type u_7} →
[inst : AddCommGroup V] →
[inst_1 : AddTorsor V P] → [inst_2 : Ring k] → [inst_3 : Module k V] → AddAction V (AffineBasis ι k P) |
Lean.Server.FileWorker.FileSetupResult.noLakefile | Lean.Server.FileWorker.SetupFile | Lean.Server.FileWorker.FileSetupResult |
Ideal.finsuppTotal | Mathlib.RingTheory.Ideal.Operations | (ι : Type u_1) →
(M : Type u_2) →
[inst : AddCommGroup M] →
{R : Type u_3} → [inst_1 : CommRing R] → [inst_2 : Module R M] → (I : Ideal R) → (ι → M) → (ι →₀ ↥I) →ₗ[R] M |
Lean.PersistentEnvExtensionDescrCore.ctorIdx | Lean.Environment | {α β σ : Type} → Lean.PersistentEnvExtensionDescrCore α β σ → ℕ |
Int64.toBitVec_ofIntTruncate | Init.Data.SInt.Lemmas | ∀ {n : ℤ}, Int64.minValue.toInt ≤ n → n ≤ Int64.maxValue.toInt → (Int64.ofIntTruncate n).toBitVec = BitVec.ofInt 64 n |
Std.Internal.List.getEntry?_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {f : (a : α) × β a → Bool} {l : List ((a : α) × β a)}
{k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getEntry? k (List.filter f l) = Option.filter f (Std.Internal.List.getEntry? k l) |
PerfectRing.comp_lift_apply | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} {M : Type u_3} [inst : CommRing K] [inst_1 : CommRing L] [inst_2 : CommRing M]
(i : K →+* L) (f : L →+* M) (p : ℕ) [inst_3 : ExpChar M p] [inst_4 : ExpChar K p] [inst_5 : PerfectRing M p]
[inst_6 : IsPRadical i p] [inst_7 : ExpChar L p] (x : L), (PerfectRing.lift i (f.comp i) p) x = f x |
WeierstrassCurve.Projective.dblXYZ_Y | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P : Fin 3 → R), W'.dblXYZ P 1 = W'.dblY P |
Set.Nonempty.star | Mathlib.Algebra.Star.Pointwise | ∀ {α : Type u_1} [inst : InvolutiveStar α] {s : Set α}, s.Nonempty → (star s).Nonempty |
Lean.DefinitionVal.mk.sizeOf_spec | Lean.Declaration | ∀ (toConstantVal : Lean.ConstantVal) (value : Lean.Expr) (hints : Lean.ReducibilityHints)
(safety : Lean.DefinitionSafety) (all : List Lean.Name),
sizeOf { toConstantVal := toConstantVal, value := value, hints := hints, safety := safety, all := all } =
1 + sizeOf toConstantVal + sizeOf value + sizeOf hints + sizeOf safety + sizeOf all |
Lean.Grind.CommRing.SPolResult.casesOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | {motive : Lean.Grind.CommRing.SPolResult → Sort u} →
(t : Lean.Grind.CommRing.SPolResult) →
((spol : Lean.Grind.CommRing.Poly) →
(k₁ : ℤ) →
(m₁ : Lean.Grind.CommRing.Mon) →
(k₂ : ℤ) →
(m₂ : Lean.Grind.CommRing.Mon) → motive { spol := spol, k₁ := k₁, m₁ := m₁, k₂ := k₂, m₂ := m₂ }) →
motive t |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.Const.minEntry?.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : Type u_2} →
(motive : (Std.DTreeMap.Internal.Impl α fun x => β) → Sort u_3) →
(x : Std.DTreeMap.Internal.Impl α fun x => β) →
(Unit → motive Std.DTreeMap.Internal.Impl.leaf) →
((size : ℕ) →
(k : α) →
(v : β) →
(r : Std.DTreeMap.Internal.Impl α fun x => β) →
motive (Std.DTreeMap.Internal.Impl.inner size k v Std.DTreeMap.Internal.Impl.leaf r)) →
((size : ℕ) →
(k : α) →
(v : β) →
(size_1 : ℕ) →
(k_1 : α) →
(v_1 : β) →
(l r r_1 : Std.DTreeMap.Internal.Impl α fun x => β) →
motive
(Std.DTreeMap.Internal.Impl.inner size k v
(Std.DTreeMap.Internal.Impl.inner size_1 k_1 v_1 l r) r_1)) →
motive x |
Set.Nontrivial.eq_1 | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} (s : Set α), s.Nontrivial = ∃ x ∈ s, ∃ y ∈ s, x ≠ y |
_private.Mathlib.CategoryTheory.Preadditive.OfBiproducts.0.CategoryTheory.SemiadditiveOfBinaryBiproducts.«term_+ᵣ_» | Mathlib.CategoryTheory.Preadditive.OfBiproducts | Lean.TrailingParserDescr |
Matroid.map_isLoop_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {e : α} {f : α → β} {hf : Set.InjOn f M.E},
autoParam (e ∈ M.E) Matroid.map_isLoop_iff._auto_1 → ((M.map f hf).IsLoop (f e) ↔ M.IsLoop e) |
PiLp.nnnorm_ofLp | Mathlib.Analysis.Normed.Lp.PiLp | ∀ {ι : Type u_2} {β : ι → Type u_4} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] (f : PiLp ⊤ β),
‖f.ofLp‖₊ = ‖f‖₊ |
Valued.toNormedField.norm_le_iff | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {L : Type u_1} [inst : Field L] {Γ₀ : Type u_2} [inst_1 : LinearOrderedCommGroupWithZero Γ₀] [val : Valued L Γ₀]
[hv : Valued.v.RankOne] {x x' : L}, ‖x‖ ≤ ‖x'‖ ↔ Valued.v x ≤ Valued.v x' |
Matrix.«_aux_Mathlib_Data_Matrix_Mul___macroRules_Matrix_term_ᵥ*__1» | Mathlib.Data.Matrix.Mul | Lean.Macro |
Topology._aux_Mathlib_Topology_Defs_Basic___macroRules_Topology_Continuous_of_1 | Mathlib.Topology.Defs.Basic | Lean.Macro |
FirstOrder.Ring.compatibleRingOfRingStructure._proof_6 | Mathlib.ModelTheory.Algebra.Ring.Basic | ∀ (R : Type u_1) [inst : FirstOrder.Language.ring.Structure R] (x : Fin 0 → R),
FirstOrder.Language.Structure.funMap FirstOrder.Ring.zeroFunc x = 0 |
CategoryTheory.Functor.natTransEquiv_symm_apply_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{F G : CategoryTheory.Functor C D} (f : F ⟶ G) (x : C)
(x_1 : (CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max v' v u)))).obj x),
(CategoryTheory.Functor.natTransEquiv.symm f).app x x_1 = CategoryTheory.Functor.HomObj.ofNatTrans f |
Std.DTreeMap.Raw.Const.getEntryGED | Std.Data.DTreeMap.Raw.Basic | {α : Type u} → {cmp : α → α → Ordering} → {β : Type v} → Std.DTreeMap.Raw α (fun x => β) cmp → α → α × β → α × β |
CategoryTheory.SpectralSequence.mk.injEq | Mathlib.Algebra.Homology.SpectralSequence.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] [inst_1 : CategoryTheory.Abelian C] {κ : Type u_2}
{c : ℤ → ComplexShape κ} {r₀ : ℤ}
(page : (r : ℤ) → autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_1 → HomologicalComplex C (c r))
(iso :
(r r' : ℤ) →
(pq : κ) →
(hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence._auto_3) →
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_5) → (page r ⋯).homology pq ≅ (page r' ⋯).X pq)
(page_1 : (r : ℤ) → autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_1 → HomologicalComplex C (c r))
(iso_1 :
(r r' : ℤ) →
(pq : κ) →
(hrr' : autoParam (r + 1 = r') CategoryTheory.SpectralSequence._auto_3) →
(hr : autoParam (r₀ ≤ r) CategoryTheory.SpectralSequence._auto_5) →
(page_1 r ⋯).homology pq ≅ (page_1 r' ⋯).X pq),
({ page := page, iso := iso } = { page := page_1, iso := iso_1 }) = (page = page_1 ∧ iso ≍ iso_1) |
CategoryTheory.Limits.preservesBinaryBiproducts_of_preservesBinaryProducts | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms]
[CategoryTheory.Limits.PreservesLimitsOfShape (CategoryTheory.Discrete CategoryTheory.Limits.WalkingPair) F],
CategoryTheory.Limits.PreservesBinaryBiproducts F |
Lean.Lsp.DiagnosticSeverity.warning | Lean.Data.Lsp.Diagnostics | Lean.Lsp.DiagnosticSeverity |
ContinuousAlternatingMap.add_apply | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] (f g : M [⋀^ι]→L[R] N) [inst_7 : ContinuousAdd N] (v : ι → M), (f + g) v = f v + g v |
Metric.PiNatEmbed.toPiNat.sizeOf_spec | Mathlib.Topology.MetricSpace.PiNat | ∀ {ι : Type u_2} {X : Type u_5} {Y : ι → Type u_6} {f : (i : ι) → X → Y i} [inst : SizeOf ι] [inst_1 : SizeOf X]
[inst_2 : (a : ι) → SizeOf (Y a)] (ofPiNat : X), sizeOf { ofPiNat := ofPiNat } = 1 + sizeOf ofPiNat |
Lean.QuotKind | Lean.Declaration | Type |
CategoryTheory.PreGaloisCategory.PointedGaloisObject.noConfusionType | Mathlib.CategoryTheory.Galois.Prorepresentability | Sort u →
{C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
[inst_1 : CategoryTheory.GaloisCategory C] →
{F : CategoryTheory.Functor C FintypeCat} →
CategoryTheory.PreGaloisCategory.PointedGaloisObject F →
{C' : Type u₁} →
[inst' : CategoryTheory.Category.{u₂, u₁} C'] →
[inst'_1 : CategoryTheory.GaloisCategory C'] →
{F' : CategoryTheory.Functor C' FintypeCat} →
CategoryTheory.PreGaloisCategory.PointedGaloisObject F' → Sort u |
_private.Mathlib.RingTheory.Support.0.Module.support_subset_of_injective._simp_1_1 | Mathlib.RingTheory.Support | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{p : PrimeSpectrum R}, (p ∈ Module.support R M) = ∃ m, ∀ r ∉ p.asIdeal, r • m ≠ 0 |
SubtractionCommMonoid.casesOn | Mathlib.Algebra.Group.Defs | {G : Type u} →
{motive : SubtractionCommMonoid G → Sort u_1} →
(t : SubtractionCommMonoid G) →
([toSubtractionMonoid : SubtractionMonoid G] →
(add_comm : ∀ (a b : G), a + b = b + a) →
motive { toSubtractionMonoid := toSubtractionMonoid, add_comm := add_comm }) →
motive t |
SSet.N.cast._proof_1 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (s : X.N) {d : ℕ} (hd : s.dim = d), (s.cast hd).simplex ∈ X.nonDegenerate (s.cast hd).dim |
ProofWidgets.instToJsonMakeEditLinkProps | ProofWidgets.Component.MakeEditLink | Lean.ToJson ProofWidgets.MakeEditLinkProps |
Aesop.instInhabitedNormSimpContext | Aesop.Search.SearchM | Inhabited Aesop.NormSimpContext |
Filter.Germ.abs_def | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : AddCommGroup β] [inst_1 : LinearOrder β] (x : (↑φ).Germ β),
|x| = Filter.Germ.map abs x |
Mathlib.Tactic.Order.AtomicFact.nle.sizeOf_spec | Mathlib.Tactic.Order.CollectFacts | ∀ (lhs rhs : ℕ) (proof : Lean.Expr),
sizeOf (Mathlib.Tactic.Order.AtomicFact.nle lhs rhs proof) = 1 + sizeOf lhs + sizeOf rhs + sizeOf proof |
Int.pow_gcd_pow | Init.Data.Int.Gcd | ∀ {n m : ℤ} {k : ℕ}, (n ^ k).gcd (m ^ k) = n.gcd m ^ k |
SheafOfModules.pushforwardPushforwardAdj._proof_5 | Mathlib.Algebra.Category.ModuleCat.Sheaf.PushforwardContinuous | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] {J : CategoryTheory.GrothendieckTopology C}
{K : CategoryTheory.GrothendieckTopology D} {F : CategoryTheory.Functor C D} {G : CategoryTheory.Functor D C}
{S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat} [inst_2 : F.IsContinuous J K]
[inst_3 : F.IsContinuous J K] [inst_4 : G.IsContinuous K J] [inst_5 : G.IsContinuous K J] (adj : F ⊣ G)
(φ : S ⟶ (F.sheafPushforwardContinuous RingCat J K).obj R) (ψ : R ⟶ (G.sheafPushforwardContinuous RingCat K J).obj S)
(H₁ :
CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.op adj.counit) R.obj =
CategoryTheory.CategoryStruct.comp ψ.hom (G.op.whiskerLeft φ.hom))
(H₂ :
CategoryTheory.CategoryStruct.comp φ.hom
(CategoryTheory.CategoryStruct.comp (F.op.whiskerLeft ψ.hom)
(CategoryTheory.Functor.whiskerRight (CategoryTheory.NatTrans.op adj.unit) S.obj)) =
CategoryTheory.CategoryStruct.id S.obj)
(X : SheafOfModules S),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.CategoryStruct.comp (SheafOfModules.pushforwardId R).inv
(CategoryTheory.CategoryStruct.comp
(SheafOfModules.pushforwardNatTrans
(CategoryTheory.CategoryStruct.id
(((CategoryTheory.Functor.id D).sheafPushforwardContinuous RingCat K K).obj R))
adj.counit)
(CategoryTheory.CategoryStruct.comp (SheafOfModules.pushforwardCongr ⋯).hom
(SheafOfModules.pushforwardComp ψ φ).inv))).app
((SheafOfModules.pushforward ψ).obj X))
((SheafOfModules.pushforward ψ).map
((CategoryTheory.CategoryStruct.comp (SheafOfModules.pushforwardComp φ ψ).hom
(CategoryTheory.CategoryStruct.comp
(SheafOfModules.pushforwardNatTrans
(CategoryTheory.CategoryStruct.comp φ ((F.sheafPushforwardContinuous RingCat J K).map ψ)) adj.unit)
(CategoryTheory.CategoryStruct.comp (SheafOfModules.pushforwardCongr ⋯).hom
(SheafOfModules.pushforwardId S).hom))).app
X)) =
CategoryTheory.CategoryStruct.id ((SheafOfModules.pushforward ψ).obj X) |
CategoryTheory.Abelian.coimageFunctorIsoImageFunctor | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] → CategoryTheory.Abelian.coim ≅ CategoryTheory.Abelian.im |
_private.Mathlib.Tactic.Linter.Whitespace.0.Mathlib.Linter.Style.Whitespace.getUnlintedRanges.match_1 | Mathlib.Tactic.Linter.Whitespace | (motive : Option Lean.Syntax.Range → Sort u_1) →
(x : Option Lean.Syntax.Range) →
((trail : Lean.Syntax.Range) → motive (some trail)) → ((x : Option Lean.Syntax.Range) → motive x) → motive x |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_modify._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) |
Interval.commMonoid | Mathlib.Algebra.Order.Interval.Basic | {α : Type u_2} → [inst : CommMonoid α] → [inst_1 : Preorder α] → [IsOrderedMonoid α] → CommMonoid (Interval α) |
_private.Mathlib.Analysis.SpecialFunctions.Log.InvLog.0.Real.not_differentiableAt_inv_log_zero._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Log.InvLog | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜}, DifferentiableAt 𝕜 f x = HasDerivAt f (deriv f x) x |
HasCardinalLT.Set.isColimitCocone._proof_2 | Mathlib.CategoryTheory.Presentable.Type | ∀ (X : Type u_1) (κ : Cardinal.{u_1}),
CategoryTheory.IsFiltered (HasCardinalLT.Set X κ) → CategoryTheory.IsFilteredOrEmpty (HasCardinalLT.Set X κ) |
_private.Lean.Meta.Tactic.Grind.Split.0.Lean.Meta.Grind.checkSplitInfoArgStatus.match_1 | Lean.Meta.Tactic.Grind.Split | (motive : Option Lean.Meta.Grind.SplitStatus → Sort u_1) →
(x : Option Lean.Meta.Grind.SplitStatus) →
(Unit → motive none) → ((a : Lean.Meta.Grind.SplitStatus) → motive (some a)) → motive x |
MeasureTheory.intervalIntegral_integral_swap | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {E : Type u_3} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace ℝ E] [MeasureTheory.SFinite μ] {a b : ℝ} {f : ℝ → α → E},
MeasureTheory.Integrable (Function.uncurry f) ((MeasureTheory.volume.restrict (Set.uIoc a b)).prod μ) →
∫ (x : ℝ) in a..b, ∫ (y : α), f x y ∂μ = ∫ (y : α), ∫ (x : ℝ) in a..b, f x y ∂μ |
MonCat.FilteredColimits.colimitMulOneClass._proof_1 | Mathlib.Algebra.Category.MonCat.FilteredColimits | ∀ {J : Type u_2} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J MonCat)
[inst_1 : CategoryTheory.IsFiltered J] (x : MonCat.FilteredColimits.M F), 1 * x = x |
CategoryTheory.StructuredArrow.preEquivalenceFunctor._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_5}
[inst_1 : CategoryTheory.Category.{u_2, u_5} D] {E : Type u_6} [inst_2 : CategoryTheory.Category.{u_4, u_6} E]
(F : CategoryTheory.Functor C D) {G : CategoryTheory.Functor D E} {e : E} (f : CategoryTheory.StructuredArrow e G)
(X : CategoryTheory.StructuredArrow f (CategoryTheory.StructuredArrow.pre e F G)),
CategoryTheory.StructuredArrow.homMk (CategoryTheory.CategoryStruct.id X).right.right ⋯ =
CategoryTheory.CategoryStruct.id (CategoryTheory.StructuredArrow.mk X.hom.right) |
Lean.Compiler.LCNF.PP.ppLetValue | Lean.Compiler.LCNF.PrettyPrinter | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LetValue pu → Lean.Compiler.LCNF.PP.M Std.Format |
AddGroupExtension.Splitting.coe_addMonoidHom_mk | Mathlib.GroupTheory.GroupExtension.Defs | ∀ {N : Type u_1} {E : Type u_2} {G : Type u_3} [inst : AddGroup N] [inst_1 : AddGroup E] [inst_2 : AddGroup G]
{S : AddGroupExtension N E G} (s : G →+ E) (hs : Function.RightInverse ⇑s ⇑S.rightHom),
↑{ toAddMonoidHom := s, rightInverse_rightHom := hs } = s |
CategoryTheory.Enriched.HasConicalLimitsOfSize.recOn | Mathlib.CategoryTheory.Enriched.Limits.HasConicalLimits | {V : Type u'} →
[inst : CategoryTheory.Category.{v', u'} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u} →
[inst_2 : CategoryTheory.Category.{v, u} C] →
[inst_3 : CategoryTheory.EnrichedOrdinaryCategory V C] →
{motive : CategoryTheory.Enriched.HasConicalLimitsOfSize.{v₁, u₁, v', v, u, u'} V C → Sort u_1} →
(t : CategoryTheory.Enriched.HasConicalLimitsOfSize.{v₁, u₁, v', v, u, u'} V C) →
((hasConicalLimitsOfShape :
∀ (J : Type u₁) [inst_4 : CategoryTheory.Category.{v₁, u₁} J],
CategoryTheory.Enriched.HasConicalLimitsOfShape J V C) →
motive ⋯) →
motive t |
GenLoop.continuous_fromLoop | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {N : Type u_1} {X : Type u_2} [inst : TopologicalSpace X] {x : X} [inst_1 : DecidableEq N] (i : N),
Continuous (GenLoop.fromLoop i) |
AddRightReflectLE | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | (M : Type u_1) → [Add M] → [LE M] → Prop |
_private.Mathlib.NumberTheory.Height.MvPolynomial.0.Height.hasFiniteMulSupport_iSup_max_iSup_one._simp_1_1 | Mathlib.NumberTheory.Height.MvPolynomial | ∀ {α : Type u_1} {M : Type u_2} [inst : One M], (Function.HasFiniteMulSupport fun x => 1) = True |
Lean.ModuleData.mk.inj | Lean.Environment | ∀ {isModule : Bool} {imports : Array Lean.Import} {constNames : Array Lean.Name} {constants : Array Lean.ConstantInfo}
{extraConstNames : Array Lean.Name} {entries : Array (Lean.Name × Array Lean.EnvExtensionEntry)} {isModule_1 : Bool}
{imports_1 : Array Lean.Import} {constNames_1 : Array Lean.Name} {constants_1 : Array Lean.ConstantInfo}
{extraConstNames_1 : Array Lean.Name} {entries_1 : Array (Lean.Name × Array Lean.EnvExtensionEntry)},
{ isModule := isModule, imports := imports, constNames := constNames, constants := constants,
extraConstNames := extraConstNames, entries := entries } =
{ isModule := isModule_1, imports := imports_1, constNames := constNames_1, constants := constants_1,
extraConstNames := extraConstNames_1, entries := entries_1 } →
isModule = isModule_1 ∧
imports = imports_1 ∧
constNames = constNames_1 ∧ constants = constants_1 ∧ extraConstNames = extraConstNames_1 ∧ entries = entries_1 |
CategoryTheory.CategoryOfElements.costructuredArrowYonedaEquivalence._proof_7 | Mathlib.CategoryTheory.Elements | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (F : CategoryTheory.Functor Cᵒᵖ (Type u_1))
{X Y : CategoryTheory.CostructuredArrow CategoryTheory.yoneda F} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.comp
(CategoryTheory.CategoryOfElements.toCostructuredArrow F)).map
f)
((fun X =>
CategoryTheory.CostructuredArrow.isoMk
(CategoryTheory.Iso.refl
(((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.comp
(CategoryTheory.CategoryOfElements.toCostructuredArrow F)).obj
X).left)
⋯)
Y).hom =
CategoryTheory.CategoryStruct.comp
((fun X =>
CategoryTheory.CostructuredArrow.isoMk
(CategoryTheory.Iso.refl
(((CategoryTheory.CategoryOfElements.fromCostructuredArrow F).rightOp.comp
(CategoryTheory.CategoryOfElements.toCostructuredArrow F)).obj
X).left)
⋯)
X).hom
((CategoryTheory.Functor.id (CategoryTheory.CostructuredArrow CategoryTheory.yoneda F)).map f) |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal.go._unary._proof_2 | Std.Time.Date.ValidDate | ∀ {leap : Bool} (ordinal : Std.Time.Day.Ordinal.OfYear leap) (idx : Std.Time.Month.Ordinal) (acc : ℤ), acc + 1 - acc = 1 |
Sublattice.map_map | Mathlib.Order.Sublattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : Lattice γ]
{L : Sublattice α} (g : LatticeHom β γ) (f : LatticeHom α β),
Sublattice.map g (Sublattice.map f L) = Sublattice.map (g.comp f) L |
SModEq.sub | Mathlib.LinearAlgebra.SModEq.Basic | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {U : Submodule R M}
{x₁ x₂ y₁ y₂ : M}, x₁ ≡ y₁ [SMOD U] → x₂ ≡ y₂ [SMOD U] → x₁ - x₂ ≡ y₁ - y₂ [SMOD U] |
Std.DTreeMap.Raw.Const.getKey?_filter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap.Raw α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{f : α → β → Bool} {k : α} (h : t.WF),
(Std.DTreeMap.Raw.filter f t).getKey? k = (t.getKey? k).pfilter fun x h' => f x (Std.DTreeMap.Raw.Const.get t x ⋯) |
Lean.Expr.FoldConstsImpl.State.mk | Lean.Util.FoldConsts | Lean.PtrSet Lean.Expr → Lean.NameHashSet → Lean.Expr.FoldConstsImpl.State |
instCommSemiringCorner._proof_6 | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} (e : R) [inst : NonUnitalCommSemiring R] (idem : IsIdempotentElem e) (x : idem.Corner),
Semiring.npow 0 x = 1 |
Lean.Elab.DocElabInfo.noConfusion | Lean.Elab.InfoTree.Types | {P : Sort u} → {t t' : Lean.Elab.DocElabInfo} → t = t' → Lean.Elab.DocElabInfo.noConfusionType P t t' |
CategoryTheory.Codiscrete.unitApp | Mathlib.CategoryTheory.CodiscreteCategory | (C : Type u) → [inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.Functor C (CategoryTheory.Codiscrete C) |
lt_of_le_of_ne' | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, b ≤ a → a ≠ b → b < a |
Int.add_modulus_mul_modEq_iff | Mathlib.Data.Int.ModEq | ∀ {n a b c : ℤ}, a + n * b ≡ c [ZMOD n] ↔ a ≡ c [ZMOD n] |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.natCast._simp_1_2 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
{a : R}, 0 ≤ a → ∀ (c : R), (0 ≤ star c * a * c) = True |
QuadraticForm.tensorRId_symm_apply | Mathlib.LinearAlgebra.QuadraticForm.TensorProduct.Isometries | ∀ {R : Type uR} {M₁ : Type uM₁} [inst : CommRing R] [inst_1 : AddCommGroup M₁] [inst_2 : Module R M₁]
[inst_3 : Invertible 2] (Q₁ : QuadraticForm R M₁) (x : M₁), Q₁.tensorRId.symm x = (TensorProduct.rid R M₁).symm x |
SSet.S.dim_eq_of_mk_eq | Mathlib.AlgebraicTopology.SimplicialSet.Simplices | ∀ {X : SSet} {n m : ℕ} {x : X.obj (Opposite.op (SimplexCategory.mk n))}
{y : X.obj (Opposite.op (SimplexCategory.mk m))}, { dim := n, simplex := x } = { dim := m, simplex := y } → n = m |
Sbtw.oangle₁₃₂_eq_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, Sbtw ℝ p₁ p₂ p₃ → EuclideanGeometry.oangle p₁ p₃ p₂ = 0 |
CommRingCat.Colimits.Prequotient.of.sizeOf_spec | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat} [inst_1 : SizeOf J]
(j : J) (x : ↑(F.obj j)), sizeOf (CommRingCat.Colimits.Prequotient.of j x) = 1 + sizeOf j + sizeOf x |
MeasureTheory.L1.measurable_coeFn | Mathlib.MeasureTheory.Function.L1Space.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
[inst_1 : MeasurableSpace β] [BorelSpace β] (f : ↥(MeasureTheory.Lp β 1 μ)), Measurable ↑↑f |
CategoryTheory.EnrichedNatTrans.mk | Mathlib.CategoryTheory.Enriched.Basic | {V : Type v} →
[inst : CategoryTheory.Category.{w, v} V] →
[inst_1 : CategoryTheory.MonoidalCategory V] →
{C : Type u₁} →
[inst_2 : CategoryTheory.EnrichedCategory V C] →
{D : Type u₂} →
[inst_3 : CategoryTheory.EnrichedCategory V D] →
{F G : CategoryTheory.EnrichedFunctor V C D} → (F.forget ⟶ G.forget) → CategoryTheory.EnrichedNatTrans F G |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.horizontal_strip._simp_1_9 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b |
Matrix.mulVec_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} {m' : Type uₘ} [inst : NonUnitalNonAssocSemiring α] (A : Matrix m' (Fin 0) α) (v : Fin 0 → α),
A.mulVec v = 0 |
DifferentiableOn.zpow | Mathlib.Analysis.Calculus.Deriv.ZPow | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type v} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {m : ℤ} {f : E → 𝕜} {t : Set E},
DifferentiableOn 𝕜 f t → (∀ x ∈ t, f x ≠ 0) ∨ 0 ≤ m → DifferentiableOn 𝕜 (fun x => f x ^ m) t |
Lat.ext | Mathlib.Order.Category.Lat | ∀ {X Y : Lat} {f g : X ⟶ Y},
(∀ (x : ↑X), (CategoryTheory.ConcreteCategory.hom f) x = (CategoryTheory.ConcreteCategory.hom g) x) → f = g |
TruncatedWittVector.truncate_wittVector_truncate | Mathlib.RingTheory.WittVector.Truncated | ∀ {p n : ℕ} {R : Type u_1} [inst : CommRing R] [inst_1 : Fact (Nat.Prime p)] {m : ℕ} (hm : n ≤ m) (x : WittVector p R),
(TruncatedWittVector.truncate hm) ((WittVector.truncate m) x) = (WittVector.truncate n) x |
StarAlgHom.rangeRestrict | Mathlib.Algebra.Star.Subalgebra | {R : Type u_2} →
{A : Type u_3} →
{B : Type u_4} →
[inst : CommSemiring R] →
[inst_1 : StarRing R] →
[inst_2 : Semiring A] →
[inst_3 : Algebra R A] →
[inst_4 : StarRing A] →
[inst_5 : Semiring B] →
[inst_6 : Algebra R B] →
[inst_7 : StarRing B] → [inst_8 : StarModule R B] → (f : A →⋆ₐ[R] B) → A →⋆ₐ[R] ↥f.range |
CategoryTheory.LocalizerMorphism.LeftResolution.instCategory._proof_4 | Mathlib.CategoryTheory.Localization.Resolution | ∀ {C₁ : Type u_2} {C₂ : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C₁]
[inst_1 : CategoryTheory.Category.{u_3, u_4} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂} {X₂ : C₂}
{X Y : Φ.LeftResolution X₂} (f : X.Hom Y), f.comp (CategoryTheory.LocalizerMorphism.LeftResolution.Hom.id Y) = f |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.monotoneOn_or_antitoneOn_iff_uIcc._simp_1_4 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (a ∈ Set.uIcc b c) = (b ≤ a ∧ a ≤ c ∨ c ≤ a ∧ a ≤ b) |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE._aux_Mathlib_Tactic_TFAE___elabRules_Mathlib_Tactic_TFAE_tfaeFinish_1._sparseCasesOn_3 | Mathlib.Tactic.TFAE | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t |
SkewPolynomial.support | Mathlib.Algebra.SkewPolynomial.Basic | {R : Type u_1} → [inst : Semiring R] → SkewPolynomial R → Finset ℕ |
_private.Aesop.Tree.ExtractProof.0.Aesop.extractProofMVarCluster.match_1 | Aesop.Tree.ExtractProof | (motive : Option Aesop.GoalRef → Sort u_1) →
(gref? : Option Aesop.GoalRef) →
((gref : Aesop.GoalRef) → motive (some gref)) → ((x : Option Aesop.GoalRef) → motive x) → motive gref? |
Set.subset_range_of_surjective | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β}, Function.Surjective f → ∀ (s : Set β), s ⊆ Set.range f |
CategoryTheory.Quotient.LiftCommShift.iso_hom_app | Mathlib.CategoryTheory.Shift.Quotient | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(F : CategoryTheory.Functor C D) (r : HomRel C) {A : Type w} [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] [inst_5 : r.IsCompatibleWithShift A]
[inst_6 : F.CommShift A] (hF : ∀ (x y : C) (f₁ f₂ : x ⟶ y), r f₁ f₂ → F.map f₁ = F.map f₂) (a : A) (X : C),
(CategoryTheory.Quotient.LiftCommShift.iso F r hF a).hom.app ((CategoryTheory.Quotient.functor r).obj X) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Quotient.lift r F hF).map
((CategoryTheory.Functor.commShiftIso (CategoryTheory.Quotient.functor r) a).inv.app X))
((CategoryTheory.Functor.commShiftIso F a).hom.app X) |
MeasureTheory.sub_eq_zero_of_upcrossingsBefore_lt | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ} {ω : Ω},
a < b →
MeasureTheory.upcrossingsBefore a b f N ω < n →
MeasureTheory.stoppedValue f (fun ω => ↑(MeasureTheory.upperCrossingTime a b f N (n + 1) ω)) ω -
MeasureTheory.stoppedValue f (fun ω => ↑(MeasureTheory.lowerCrossingTime a b f N n ω)) ω =
0 |
trans_trichotomous_left | Mathlib.Order.Defs.Unbundled | ∀ {α : Type u_1} {r : α → α → Prop} [IsTrans α r] [Std.Trichotomous r] {a b c : α}, ¬r b a → r b c → r a c |
ProbabilityTheory.Kernel.iIndepSets_zero_right._simp_1 | Mathlib.Probability.Independence.Kernel.Indep | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {π : ι → Set (Set Ω)}, ProbabilityTheory.Kernel.iIndepSets π κ 0 = True |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.