name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
AddEquiv.toRealLinearEquiv._proof_3 | Mathlib.Topology.Instances.RealVectorSpace | ∀ {E : Type u_2} [inst : AddCommGroup E] {F : Type u_1} [inst_1 : AddCommGroup F] (e : E ≃+ F) (x y : E),
e.toFun (x + y) = e.toFun x + e.toFun y | null | false |
MonoidHom.coe_compAddChar._simp_1 | Mathlib.Algebra.Group.AddChar | ∀ {A : Type u_1} {M : Type u_3} [inst : AddMonoid A] [inst_1 : Monoid M] {N : Type u_5} [inst_2 : Monoid N] (f : M →* N)
(φ : AddChar A M), ⇑f ∘ ⇑φ = ⇑(f.compAddChar φ) | null | false |
_private.Mathlib.NumberTheory.Padics.Measure.Basic.0.AbstractMeasure.arrowCongrLeft._proof_2 | Mathlib.NumberTheory.Padics.Measure.Basic | ∀ {X : Type u_4} {Y : Type u_1} {R : Type u_2} {E : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
[inst_2 : AddCommGroup E] [inst_3 : TopologicalSpace E] [inst_4 : IsTopologicalAddGroup E] [inst_5 : CommRing R]
[inst_6 : TopologicalSpace R] [inst_7 : IsTopologicalRing R] [inst_8 : Module R E] ... | null | false |
CategoryTheory.Pseudofunctor.mk.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
[inst_2 : SizeOf B] [inst_3 : SizeOf C] (toPrelaxFunctor : CategoryTheory.PrelaxFunctor B C)
(mapId :
(a : B) →
toPrelaxFunctor.map (CategoryTheory.CategoryStruct.id a) ≅
CategoryTheory.Catego... | null | true |
AdjoinRoot.liftAlgHom.eq_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} {T : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : CommRing T]
[inst_3 : Algebra S R] [inst_4 : Algebra S T] (p : Polynomial R) (i : R →ₐ[S] T) (x : T)
(h : Polynomial.eval₂ (↑i) x p = 0),
AdjoinRoot.liftAlgHom p i x h = { toRingHom := AdjoinRoot.lift i.toRingHom x ... | null | true |
instHashable | Init.Data.Hashable | (P : Prop) → Hashable P | null | true |
IsPrimitiveRoot.iff_orderOf | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {M : Type u_1} [inst : CommMonoid M] {k : ℕ} {ζ : M}, IsPrimitiveRoot ζ k ↔ orderOf ζ = k | null | true |
instCommRingFreeCommRing._proof_12 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1) (a b : FreeCommRing α), a + b = b + a | null | false |
Std.ExtHashMap.getD_congr | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {a b : α} {fallback : β}, (a == b) = true → m.getD a fallback = m.getD b fallback | null | true |
CategoryTheory.OverPresheafAux.unit._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.OverPresheafAux.restrictedYoneda A).comp
(CategoryTheory.OverPresheafAux.costructuredArrowPresh... | null | false |
Module.Basis.coe_algebraMapCoeffs | Mathlib.RingTheory.AlgebraTower | ∀ {R : Type u_1} (A : Type u_3) {ι : Type u_5} {M : Type u_6} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : AddCommMonoid M] [inst_3 : Algebra R A] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (b : Module.Basis ι R M) (h : Function.Bijective ⇑(algebraMap R A)),
⇑(Module.Bas... | null | true |
_private.Mathlib.MeasureTheory.Constructions.HaarToSphere.0.MeasureTheory.Measure.toSphere_ne_zero._simp_1_2 | Mathlib.MeasureTheory.Constructions.HaarToSphere | ∀ (α : Type u_3) [Nontrivial α], Subsingleton α = False | null | false |
_private.Mathlib.Algebra.BigOperators.Ring.Finset.0.Finset.prod_add._simp_1_11 | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {α : Sort u_1} {p : α → Prop}, (¬∃ x, p x) = ∀ (x : α), ¬p x | null | false |
continuousWithinAt_Icc_iff_Ici._simp_1 | Mathlib.Topology.Order.OrderClosed | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [ClosedIciTopology α]
[inst_3 : TopologicalSpace β] {a b : α} {f : α → β},
b < a → ContinuousWithinAt f (Set.Icc b a) b = ContinuousWithinAt f (Set.Ici b) b | null | false |
CategoryTheory.Localization.StrictUniversalPropertyFixedTarget.prodLift | Mathlib.CategoryTheory.Localization.Prod | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{E : Type u₅} →
[inst_2 : CategoryTheory.Categ... | The lifting of a functor `F : C₁ × C₂ ⥤ E` inverting `W₁.prod W₂` to a functor
`W₁.Localization × W₂.Localization ⥤ E` | true |
CategoryTheory.Arrow.comp_left_assoc | Mathlib.CategoryTheory.Comma.Arrow | ∀ {T : Type u} [inst : CategoryTheory.Category.{v, u} T] {X Y Z : CategoryTheory.Arrow T} (f : X ⟶ Y) (g : Y ⟶ Z)
{Z_1 : T} (h : Z.left ⟶ Z_1),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow.Hom.left (CategoryTheory.CategoryStruct.comp f g)) h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Arrow... | null | true |
List.filter_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {L : List (List α)}, List.filter p L.flatten = (List.map (List.filter p) L).flatten | null | true |
CategoryTheory.Functor.whiskerLeft | Mathlib.CategoryTheory.Whiskering | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{E : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} E] →
(F : CategoryTheory.Functor C D) → {G H : CategoryTheory.Functor D E} → (G ⟶ H) → (F.com... | If `α : G ⟶ H` then `whiskerLeft F α : F ⋙ G ⟶ F ⋙ H` has components `α.app (F.obj X)`. | true |
NumberField.Ideal.primesOverSpanEquivMonicFactorsMod_symm_apply | Mathlib.NumberTheory.NumberField.Ideal.KummerDedekind | ∀ {K : Type u_1} [inst : Field K] {θ : NumberField.RingOfIntegers K} {p : ℕ} [inst_1 : Fact (Nat.Prime p)]
[inst_2 : NumberField K] (hp : ¬p ∣ RingOfIntegers.exponent θ) {Q : Polynomial (ZMod p)}
(hQ : Q ∈ RingOfIntegers.monicFactorsMod θ p),
↑((NumberField.Ideal.primesOverSpanEquivMonicFactorsMod hp).symm ⟨Q, hQ... | null | true |
CategoryTheory.imageUnopUnop.eq_1 | Mathlib.Algebra.Homology.Opposite | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {A B : Cᵒᵖ}
(g : A ⟶ B), CategoryTheory.imageUnopUnop g = (CategoryTheory.imageUnopOp g).unop | null | true |
Aesop.RawHyp.fvarId.inj | Aesop.Forward.State | ∀ {fvarId fvarId_1 : Lean.FVarId}, Aesop.RawHyp.fvarId fvarId = Aesop.RawHyp.fvarId fvarId_1 → fvarId = fvarId_1 | null | true |
CategoryTheory.Pi.monoidalPi'._proof_6 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : Type u_5}
[inst_2 : CategoryTheory.Category.{u_4, u_5} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(F : (i : I) → CategoryTheory.Functor D (C i)) [ins... | null | false |
CauSeq.Completion.ofRat_ratCast | Mathlib.Algebra.Order.CauSeq.Completion | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] {β : Type u_2}
[inst_3 : DivisionRing β] {abv : β → α} [inst_4 : IsAbsoluteValue abv] (q : ℚ), CauSeq.Completion.ofRat ↑q = ↑q | null | true |
CategoryTheory.Adjunction.leftAdjointCompNatTrans₀₂₃_eq_conjugateEquiv_symm | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} {C₁ : Type u_2} {C₂ : Type u_3} {C₃ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₀]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₁] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₂]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₃] {F₀₁ : CategoryTheory.Functor C₀ C₁}
{F₁₂ : CategoryTh... | null | true |
TensorProduct.mapL_add_right | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} {H : Type u_5} [inst : RCLike 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F]
[inst_4 : InnerProductSpace 𝕜 F] [inst_5 : NormedAddCommGroup G] [inst_6 : InnerProductSpace 𝕜 G]
[inst_7 : NormedAdd... | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.MonoidHom.isMulCommutative_of_isCyclic_of_ker_le_center._simp_1_7 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a : G) (n : ℕ), a ^ n = a ^ ↑n | null | false |
_aux_Mathlib_Algebra_Algebra_NonUnitalHom___unexpand_NonUnitalAlgHom_2 | Mathlib.Algebra.Algebra.NonUnitalHom | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Tactic.ClickSuggestions.TryPremises.0.Mathlib.Tactic.ClickSuggestions.Candidates.appAt.noConfusion | Mathlib.Tactic.ClickSuggestions.TryPremises | {P : Sort u} →
{arr arr' : Array Mathlib.Tactic.ClickSuggestions.ApplyAtLemma} →
Mathlib.Tactic.ClickSuggestions.Candidates.appAt✝ arr = Mathlib.Tactic.ClickSuggestions.Candidates.appAt✝ arr' →
(arr = arr' → P) → P | null | false |
UniformSpace.Core.mk._flat_ctor | Mathlib.Topology.UniformSpace.Defs | {α : Type u} →
(uniformity : Filter (α × α)) →
Filter.principal SetRel.id ≤ uniformity →
Filter.Tendsto Prod.swap uniformity uniformity →
(uniformity.lift' fun s => SetRel.comp s s) ≤ uniformity → UniformSpace.Core α | null | false |
specializes_of_eq | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, x = y → x ⤳ y | null | true |
ContDiffAt.comp | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {f : E → F} {g : F → G} {n : WithTop ... | The composition of `C^n` functions at points is `C^n`. | true |
_private.Lean.Meta.Sym.ReplaceS.0.Lean.Meta.Sym.visitChild.match_1 | Lean.Meta.Sym.ReplaceS | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((mvarId : Lean.MVarId) → motive (Lean.Expr.mvar mvarId)) →
((deBruijnIndex : ℕ) → motive (Lean.Expr.bvar deBruijnIndex)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
... | null | false |
Set.mem_one._simp_2 | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : One α] {a : α}, (a ∈ 1) = (a = 1) | null | false |
CategoryTheory.Pseudofunctor.comp._proof_6 | Mathlib.CategoryTheory.Bicategory.Functor.Pseudofunctor | ∀ {B : Type u_2} [inst : CategoryTheory.Bicategory B] {C : Type u_9} [inst_1 : CategoryTheory.Bicategory C]
{D : Type u_6} [inst_2 : CategoryTheory.Bicategory D] (F : CategoryTheory.Pseudofunctor B C)
(G : CategoryTheory.Pseudofunctor C D) {a b c d : B} (f : a ⟶ b) (g : b ⟶ c) (h : c ⟶ d),
(F.comp G.toPrelaxFunct... | null | false |
val_inv_unitsNonZeroDivisorsEquiv_symm_apply_coe | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (u : M₀ˣ), ↑↑(unitsNonZeroDivisorsEquiv.symm u)⁻¹ = ↑u⁻¹ | null | true |
TopologicalSpace.vietoris.isClosed_inter_nonempty_of_isClosed | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {F : Set α}, IsClosed F → IsClosed {s | (s ∩ F).Nonempty} | null | true |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsProperLinearSet.mem_iff_fract_eq_and_floor_nonneg.match_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} {s : Set (ι → ℕ)} (hs : IsProperLinearSet s) [inst : Finite ι] (x : ι → ℕ)
(motive :
(IsProperLinearSet.fract✝ hs x = IsProperLinearSet.base✝ hs ∧
∀ (i : ↑(IsProperLinearSet.basisSet✝ hs)),
0 ≤ IsProperLinearSet.floor✝ hs x i ∧
(↑i ∉ IsProperLinearSet.periods✝ hs → I... | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.toCNF_add_entails_toCNF_insert._simp_1_3 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ {assign : Std.Tactic.BVDecide.LRAT.Internal.Assignment} (a : ℕ → Bool),
Std.Sat.CNF.Sat a assign.toCNF = ∀ (atom : ℕ) (pol : Bool), assign.get? atom = some pol → a atom = pol | null | false |
UInt8.toBitVec_mod | Init.Data.UInt.Lemmas | ∀ {a b : UInt8}, (a % b).toBitVec = a.toBitVec % b.toBitVec | null | true |
CategoryTheory.FilteredObject.Hom._sizeOf_inst | Mathlib.CategoryTheory.Filtration.Basic | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{I : Type u_1} →
{inst_1 : CategoryTheory.Category.{u_2, u_1} I} →
(F G : CategoryTheory.FilteredObject C I) → [SizeOf C] → [SizeOf I] → SizeOf (F.Hom G) | null | false |
Lean.Elab.Do.ControlStack.rec | Lean.Elab.Do.Control | {motive : Lean.Elab.Do.ControlStack → Sort u} →
((description : Unit → Lean.MessageData) →
(m : Lean.Elab.Do.DoElabM Lean.Expr) →
(stM runInBase : Lean.Expr → Lean.Elab.Do.DoElabM Lean.Expr) →
(restoreCont : Lean.Elab.Do.DoElemCont → Lean.Elab.Do.DoElabM Lean.Elab.Do.DoElemCont) →
... | null | false |
not_isBot._simp_3 | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LE α] [NoBotOrder α] (a : α), IsBot a = False | null | false |
Std.Async.System.instInhabitedSystemUser.default | Std.Async.System | Std.Async.System.SystemUser | null | true |
AbsoluteValue.toNormedRing._proof_9 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_1} [inst : Ring R] (v : AbsoluteValue R ℝ) (x y : R), v (x * y) ≤ v x * v y | null | false |
ProbabilityTheory.condVar_of_ae_eq_zero_or_one | Mathlib.Probability.Distributions.TwoValued | ∀ {Ω : Type u_1} {m : MeasurableSpace Ω} {X : Ω → ℝ} {m₀ : MeasurableSpace Ω},
m ≤ m₀ →
∀ {μ : MeasureTheory.Measure Ω} [MeasureTheory.IsFiniteMeasure μ],
AEMeasurable X μ →
(∀ᵐ (ω : Ω) ∂μ, X ω = 0 ∨ X ω = 1) → ProbabilityTheory.condVar m X μ =ᵐ[μ] μ[X | m] * μ[1 - X | m] | If a random variable is ae equal to `0` or `1`, then its conditional variance is the product of
the conditional probabilities that it's equal to `0` and that it's equal to `1`. | true |
_private.Mathlib.Data.ENat.Basic.0.ENat.natCast_ne_top.match_1_1 | Mathlib.Data.ENat.Basic | ∀ (a : ℕ) (motive : ↑a = ⊤ → Prop) (a : ↑a = ⊤), motive a | null | false |
Metric.sphere.instHasDistribNeg._proof_2 | Mathlib.Analysis.Normed.Field.UnitBall | ∀ {𝕜 : Type u_1} [inst : SeminormedRing 𝕜] (x : ↑(Metric.sphere 0 1)), ↑(-x) = ↑(-x) | null | false |
RingEquiv.rec | Mathlib.Algebra.Ring.Equiv | {R : Type u_7} →
{S : Type u_8} →
[inst : Mul R] →
[inst_1 : Mul S] →
[inst_2 : Add R] →
[inst_3 : Add S] →
{motive : R ≃+* S → Sort u} →
((toEquiv : R ≃ S) →
(map_mul' : ∀ (x y : R), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
... | null | false |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_def_odd._simp_1_4 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {ι : Type u_1} {G : Type u_5} {s : Finset ι} [inst : SubtractionCommMonoid G] (f : ι → G),
-∑ x ∈ s, f x = ∑ x ∈ s, -f x | null | false |
ProbabilityTheory.IsSFiniteKernel.casesOn | Mathlib.Probability.Kernel.Defs | {α : Type u_1} →
{β : Type u_2} →
{mα : MeasurableSpace α} →
{mβ : MeasurableSpace β} →
{κ : ProbabilityTheory.Kernel α β} →
{motive : ProbabilityTheory.IsSFiniteKernel κ → Sort u} →
(t : ProbabilityTheory.IsSFiniteKernel κ) →
((tsum_finite :
∃... | null | false |
Besicovitch.exists_disjoint_closedBall_covering_ae_aux | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ {α : Type u_1} [inst : MetricSpace α] [SecondCountableTopology α] [inst_2 : MeasurableSpace α]
[OpensMeasurableSpace α] [HasBesicovitchCovering α] (μ : MeasureTheory.Measure α) [MeasureTheory.SFinite μ]
(f : α → Set ℝ) (s : Set α),
(∀ x ∈ s, ∀ δ > 0, (f x ∩ Set.Ioo 0 δ).Nonempty) →
∃ t,
t.Countable ∧
... | The measurable **Besicovitch covering theorem**.
Assume that, for any `x` in a set `s`, one is given a set of admissible closed balls centered at
`x`, with arbitrarily small radii. Then there exists a disjoint covering of almost all `s` by
admissible closed balls centered at some points of `s`.
This version requires ... | true |
_private.Aesop.Builder.Unfold.0.Aesop.RuleBuilder.checkUnfoldableConst.match_1 | Aesop.Builder.Unfold | (motive : Option (Lean.Expr × Array Lean.Name) → Sort u_1) →
(unfoldResult : Option (Lean.Expr × Array Lean.Name)) →
(Unit → motive none) → ((e' : Lean.Expr) → (snd : Array Lean.Name) → motive (some (e', snd))) → motive unfoldResult | null | false |
StructureGroupoid.LocalInvariantProp.liftPropWithinAt_mono_of_mem_nhdsWithin | Mathlib.Geometry.Manifold.LocalInvariantProperties | ∀ {H : Type u_1} {M : Type u_2} {H' : Type u_3} {M' : Type u_4} [inst : TopologicalSpace H]
[inst_1 : TopologicalSpace M] [inst_2 : ChartedSpace H M] [inst_3 : TopologicalSpace H']
[inst_4 : TopologicalSpace M'] [inst_5 : ChartedSpace H' M'] {P : (H → H') → Set H → H → Prop} {g : M → M'}
{s t : Set M} {x : M},
... | null | true |
CategoryTheory.InjectiveResolution.wrapped._@.Mathlib.CategoryTheory.Abelian.Injective.Resolution.4211954440._hygCtx._hyg.8 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | Subtype (Eq @CategoryTheory.InjectiveResolution.definition✝) | null | false |
Std.instStreamIterOfProductiveOfIteratorAccessId._proof_1 | Init.Data.Iterators.Consumers.Stream | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] (it : Std.Iter β) (it_1 : Std.IterM Id β),
Std.IterM.IsPlausibleNthOutputStep 0 it.toIterM (Std.IterStep.skip it_1) → False | null | false |
_private.Batteries.CodeAction.Basic.0.Batteries.CodeAction.tacticCodeActionProvider._sparseCasesOn_14 | Batteries.CodeAction.Basic | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.NumberTheory.Wilson.0.ZMod.wilsons_lemma._simp_1_1 | Mathlib.NumberTheory.Wilson | ∀ {M : Type u} [inst : Monoid M] (x : Mˣ), ↑x = (Units.coeHom M) x | null | false |
Finset.sum_disjUnion | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {ι : Type u_1} {M : Type u_4} {s₁ s₂ : Finset ι} [inst : AddCommMonoid M] {f : ι → M} (h : Disjoint s₁ s₂),
∑ x ∈ s₁.disjUnion s₂ h, f x = ∑ x ∈ s₁, f x + ∑ x ∈ s₂, f x | null | true |
CategoryTheory.MorphismProperty.instIsStableUnderCobaseChangeFunctorFunctorCategoryOfHasPushouts | Mathlib.CategoryTheory.MorphismProperty.FunctorCategory | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C}
[W.IsStableUnderCobaseChange] (J : Type u'') [inst_2 : CategoryTheory.Category.{v'', u''} J]
[CategoryTheory.Limits.HasPushouts C], (W.functorCategory J).IsStableUnderCobaseChange | null | true |
CategoryTheory.Limits.hasCoequalizers_opposite | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Equalizers | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.Limits.HasEqualizers C],
CategoryTheory.Limits.HasCoequalizers Cᵒᵖ | null | true |
Filter.eventually_atBot_curry | Mathlib.Order.Filter.AtTopBot.Prod | ∀ {α : Type u_3} {β : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] {p : α × β → Prop},
(∀ᶠ (x : α × β) in Filter.atBot, p x) → ∀ᶠ (k : α) in Filter.atBot, ∀ᶠ (l : β) in Filter.atBot, p (k, l) | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan.0.Mathlib.Meta.Positivity.evalRealArctan.match_6 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Arctan | {u : Lean.Level} →
{α : Q(Type u)} →
(motive : Option Q(PartialOrder «$α») → Sort u_1) →
(p : Option Q(PartialOrder «$α»)) →
(Unit → motive none) → ((p : Q(PartialOrder «$α»)) → motive (some p)) → motive p | null | false |
_private.Init.Data.Array.Nat.0.Array.sum_eq_zero_iff_forall_eq_nat._simp_1_2 | Init.Data.Array.Nat | ∀ {xs : List ℕ}, (xs.sum = 0) = ∀ x ∈ xs, x = 0 | null | false |
CategoryTheory.AddMon.Hom.rec | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{M N : CategoryTheory.AddMon C} →
{motive : M.Hom N → Sort u} →
((hom : M.X ⟶ N.X) →
[isAddMonHom_hom : CategoryTheory.IsAddMonHom hom] →
motive { hom ... | null | false |
Module.Presentation.CokernelData.recOn | Mathlib.Algebra.Module.Presentation.Cokernel | {A : Type u} →
[inst : Ring A] →
{M₁ : Type v₁} →
{M₂ : Type v₂} →
[inst_1 : AddCommGroup M₁] →
[inst_2 : Module A M₁] →
[inst_3 : AddCommGroup M₂] →
[inst_4 : Module A M₂] →
{pres₂ : Module.Presentation A M₂} →
{f : M₁ →ₗ[A] M₂} ... | null | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_smod._simp_1_2 | Init.Data.BitVec.Bitblast | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
Finset.addEnergy_univ_left | Mathlib.Combinatorics.Additive.Energy | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : AddCommGroup α] [inst_2 : Fintype α] (t : Finset α),
Finset.univ.addEnergy t = Fintype.card α * t.card ^ 2 | null | true |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.finitenessRelation._proof_2 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice} {it it' : Std.IterM Id s.Subslice},
it'.IsPlausibleSuccessorOf it →
InvImage (Option.lt Std.Iter.I... | null | false |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult._sizeOf_1 | Lean.Meta.InferType | Lean.Meta.ArrowPropResult✝ → ℕ | null | false |
Finset.sum_eq_zero_iff_of_nonpos | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : AddCommMonoid N] [inst_1 : PartialOrder N] {f : ι → N} {s : Finset ι}
[IsOrderedAddMonoid N], (∀ i ∈ s, f i ≤ 0) → (∑ i ∈ s, f i = 0 ↔ ∀ i ∈ s, f i = 0) | null | true |
AlgebraicGeometry.SheafedSpace._sizeOf_inst | Mathlib.Geometry.RingedSpace.SheafedSpace | (C : Type u) → {inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (AlgebraicGeometry.SheafedSpace C) | null | false |
ConjAct.instGroupWithZero | Mathlib.Algebra.GroupWithZero.Action.ConjAct | {G₀ : Type u_2} → [GroupWithZero G₀] → GroupWithZero (ConjAct G₀) | null | true |
BoundedContinuousFunction.instSemilatticeInf._proof_3 | Mathlib.Topology.ContinuousMap.Bounded.Normed | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : NormedAddCommGroup β] [inst_2 : Lattice β]
[inst_3 : HasSolidNorm β] [inst_4 : IsOrderedAddMonoid β] (a b c : BoundedContinuousFunction α β),
a ≤ b → a ≤ c → a ≤ { toFun := ⇑b ⊓ ⇑c, continuous_toFun := ⋯, map_bounded' := ⋯ } | null | false |
CategoryTheory.ShortComplex.Exact.leftHomologyDataOfIsLimitKernelFork._proof_1 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{S : CategoryTheory.ShortComplex C} (kf : CategoryTheory.Limits.KernelFork S.g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Iso.refl kf.pt).hom
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.Ke... | null | false |
Topology.CWComplex.FiniteType.finite_cell | Mathlib.Topology.CWComplex.Classical.Finite | ∀ {X : Type u} {inst : TopologicalSpace X} {C D : Set X} {inst_1 : Topology.RelCWComplex C D}
[self : Topology.RelCWComplex.FiniteType C] (n : ℕ), Finite (Topology.RelCWComplex.cell C n) | **Alias** of `Topology.RelCWComplex.FiniteType.finite_cell`.
---
`cell C n` is finite for every `n`. | true |
Lean.Parser.Term.quot.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | null | true |
Bimod.noConfusion | Mathlib.CategoryTheory.Monoidal.Bimod | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{A B : CategoryTheory.Mon C} →
{t : Bimod A B} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{inst'_1 :... | null | false |
Std.Http.URI.Port.value.injEq | Std.Http.Data.URI.Basic | ∀ (port port_1 : UInt16), (Std.Http.URI.Port.value port = Std.Http.URI.Port.value port_1) = (port = port_1) | null | true |
Real.rpow_def_of_nonneg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {x : ℝ}, 0 ≤ x → ∀ (y : ℝ), x ^ y = if x = 0 then if y = 0 then 1 else 0 else Real.exp (Real.log x * y) | null | true |
_private.Lean.Meta.Tactic.Grind.EMatch.0.Lean.Meta.Grind.EMatch.saveSource | Lean.Meta.Tactic.Grind.EMatch | Lean.Meta.Grind.EMatch.Choice → Lean.Expr → Lean.Meta.Grind.GoalM Lean.Meta.Grind.EMatch.Choice | Save `e.ematchDiagSource` in `c` if it is not `.other`.
This is used to implement `grind.ematch.diagnostics`.
| true |
Lean.Elab.Tactic.Omega.State.noConfusion | Lean.Elab.Tactic.Omega.OmegaM | {P : Sort u} → {t t' : Lean.Elab.Tactic.Omega.State} → t = t' → Lean.Elab.Tactic.Omega.State.noConfusionType P t t' | null | false |
Submodule.lt_sup_iff_notMem | Mathlib.LinearAlgebra.Span.Defs | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I : Submodule R M}
{a : M}, I < I ⊔ R ∙ a ↔ a ∉ I | null | true |
tsupport_add | Mathlib.Topology.Algebra.Support | ∀ {X : Type u_1} {α : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddZeroClass α] (f g : X → α),
(tsupport fun x => f x + g x) ⊆ tsupport f ∪ tsupport g | null | true |
BialgHom.mk_coe | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
{f : A →ₐc[R] B} (h₀ : ∀ (x y : A), f (x + y) = f x + f y)
(h₁ :
∀ (m : R) (x : A),
... | null | true |
_private.Mathlib.Tactic.ApplyFun.0.Mathlib.Tactic.applyFunHyp.match_6 | Mathlib.Tactic.ApplyFun | (motive : Option Lean.Expr → Sort u_1) →
(using? : Option Lean.Expr) → ((r : Lean.Expr) → motive (some r)) → (Unit → motive none) → motive using? | null | false |
Lean.Meta.Grind.EMatchTheoremConstraint.depthLt | Lean.Meta.Tactic.Grind.Extension | ℕ → ℕ → Lean.Meta.Grind.EMatchTheoremConstraint | A constraint of the form `depth lhs < n`. The `lhs` is one of the bound variables.
The depth is computed in constant time using the `approxDepth` field attached to expressions.
| true |
_private.Mathlib.LinearAlgebra.Matrix.PosDef.0.Matrix.PosSemidef.smul._simp_1_1 | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {α : Type u_1} {β : Type u_2} {R : Type u_3} {M : Type u_5} [inst : Zero β] [inst_1 : AddCommMonoid M]
[inst_2 : DistribSMul R M] {v : α →₀ β} {c : R} {h : α → β → M}, (v.sum fun a b => c • h a b) = c • v.sum h | null | false |
enorm_pos | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_7} [inst : TopologicalSpace E] [inst_1 : ENormedAddMonoid E] {a : E}, 0 < ‖a‖ₑ ↔ a ≠ 0 | null | true |
DoubleQuot.coe_quotQuotEquivQuotSupₐ_symm | Mathlib.RingTheory.Ideal.Quotient.Operations | ∀ (R : Type u) {A : Type u_1} [inst : CommSemiring R] [inst_1 : CommRing A] [inst_2 : Algebra R A] (I J : Ideal A),
⇑(DoubleQuot.quotQuotEquivQuotSupₐ R I J).symm = ⇑(DoubleQuot.quotQuotEquivQuotSup I J).symm | null | true |
_private.Init.Data.Slice.Array.Lemmas.0.Subarray.toList_mkSlice_rco._simp_1_2 | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, xs.size = xs.toList.length | null | false |
LinearMap.BilinForm.apply_eq_dotProduct_toMatrix_mulVec | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₁ : Type u_1} {M₁ : Type u_2} [inst : CommSemiring R₁] [inst_1 : AddCommMonoid M₁] [inst_2 : Module R₁ M₁]
{n : Type u_5} [inst_3 : Fintype n] [inst_4 : DecidableEq n] (b : Module.Basis n R₁ M₁)
(B : LinearMap.BilinForm R₁ M₁) (x y : M₁),
(B x) y = ⇑(b.repr x) ⬝ᵥ ((LinearMap.BilinForm.toMatrix b) B).mulVec ⇑(... | null | true |
PiNat.wrapped._@.Mathlib.Topology.MetricSpace.PiNat.2189032603._hygCtx._hyg.8 | Mathlib.Topology.MetricSpace.PiNat | Subtype (Eq @PiNat.definition✝) | null | false |
_private.Mathlib.FieldTheory.AxGrothendieck.0.FirstOrder.realize_genericPolyMapSurjOnOfInjOn._simp_1_3 | Mathlib.FieldTheory.AxGrothendieck | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{φ : L.Formula (α ⊕ β)} {v : α → M} {v' : Fin 0 → M},
FirstOrder.Language.BoundedFormula.Realize (FirstOrder.Language.Formula.iAlls β φ) v v' =
∀ (i : β → M), φ.Realize fun a => Sum.elim v i a | null | false |
LieRing.noConfusion | Mathlib.Algebra.Lie.Basic | {P : Sort u} →
{L : Type v} → {t : LieRing L} → {L' : Type v} → {t' : LieRing L'} → L = L' → t ≍ t' → LieRing.noConfusionType P t t' | null | false |
_private.Mathlib.Tactic.Linter.Style.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.Style.3276061806._hygCtx._hyg.4 | Mathlib.Tactic.Linter.Style | IO (Lean.Option Bool) | null | false |
CategoryTheory.Limits.ColimitPresentation.map_diag | Mathlib.CategoryTheory.Limits.Presentation | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.Category.{t, w} J]
{X : C} (P : CategoryTheory.Limits.ColimitPresentation J X) {D : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D)
[inst_3 : CategoryTheory.Limits.PreservesCol... | null | true |
Shrink.linearEquiv_apply | Mathlib.Algebra.Module.Shrink | ∀ (R : Type u_1) (α : Type u_2) [inst : Small.{v, u_2} α] [inst_1 : Semiring R] [inst_2 : AddCommMonoid α]
[inst_3 : Module R α] (a : Shrink.{v, u_2} α), (Shrink.linearEquiv R α) a = (equivShrink α).symm a | null | true |
Lake.Date.mk | Lake.Util.Date | ℕ → ℕ → ℕ → Lake.Date | null | true |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.instInfSet._simp_4 | Mathlib.Probability.Process.Filtration | ∀ {α : Sort u_1} {p : α → Prop} {q : (∃ x, p x) → Prop}, (∀ (h : ∃ x, p x), q h) = ∀ (x : α) (h : p x), q ⋯ | null | false |
LE.ofLT.eq_1 | Init.Data.Order.Factories | ∀ (α : Type u) [inst : LT α], LE.ofLT α = { le := fun a b => ¬b < a } | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.