name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
MeasureTheory.lpMeasSubgroupToLpTrim_neg | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) (f : ↥(MeasureTheory.lpMeasSubgroup F m p μ)),
MeasureTheory.lpMeasSubgroupToLpTrim F p μ hm (-f) = -MeasureTheory.lpMeasSubgroupToLpTrim F p μ hm f | true |
_private.Lean.Environment.0.Lean.RealizationContext.casesOn | Lean.Environment | {motive : Lean.RealizationContext✝ → Sort u} →
(t : Lean.RealizationContext✝¹) →
((env : NonScalar) →
(opts : Lean.Options) →
(realizeMapRef : IO.Ref (Lean.NameMap NonScalar)) →
motive { env := env, opts := opts, realizeMapRef := realizeMapRef }) →
motive t | false |
Ordinal.mul_div_le | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a b : Ordinal.{u_4}), b * (a / b) ≤ a | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.elabParserName.match_1 | Lean.Elab.Syntax | (motive : Option Lean.Parser.ParserResolution → Sort u_1) →
(__do_lift : Option Lean.Parser.ParserResolution) →
((n : Lean.Parser.ParserResolution) → motive (some n)) → (Unit → motive none) → motive __do_lift | false |
Lean.ResolveName.resolveGlobalName | Lean.ResolveName | Lean.Environment → Lean.Options → Lean.Name → List Lean.OpenDecl → Lean.Name → List (Lean.Name × List String) | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH.match_1 | Lean.Meta.IndPredBelow | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((f : Lean.FVarId) → motive (Lean.Expr.fvar f)) → ((x : Lean.Expr) → motive x) → motive x | false |
_private.Init.Prelude.0.Lean.Macro.State.mk.noConfusion | Init.Prelude | {P : Sort u} →
{macroScope : Lean.MacroScope} →
{traceMsgs : List (Lean.Name × String)} →
{expandedMacroDecls : List Lean.Name} →
{macroScope' : Lean.MacroScope} →
{traceMsgs' : List (Lean.Name × String)} →
{expandedMacroDecls' : List Lean.Name} →
{ macroScope := macroScope, traceMsgs := traceMsgs, expandedMacroDecls := expandedMacroDecls } =
{ macroScope := macroScope', traceMsgs := traceMsgs', expandedMacroDecls := expandedMacroDecls' } →
(macroScope = macroScope' → traceMsgs = traceMsgs' → expandedMacroDecls = expandedMacroDecls' → P) → P | false |
NonUnitalRingHom.op_apply_apply | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_3} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(f : R →ₙ+* S) (a : Rᵐᵒᵖ), (NonUnitalRingHom.op f) a = (↑(AddMonoidHom.mulOp f.toAddMonoidHom)).toFun a | true |
Commute.function_commute_mul_right | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Semigroup G] {a b : G}, Commute a b → Function.Commute (fun x => x * a) fun x => x * b | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.mk_isRelPrime_iff._simp_1_2 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {p : Associates M → Prop},
(∀ (a : Associates M), p a) = ∀ (a : M), p (Associates.mk a) | false |
Turing.ToPartrec.Cont._sizeOf_inst | Mathlib.Computability.TuringMachine.Config | SizeOf Turing.ToPartrec.Cont | false |
NNRat.den_one | Mathlib.Data.NNRat.Defs | NNRat.den 1 = 1 | true |
Std.DHashMap.Raw.Const.get!_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] [inst_4 : Inhabited γ] {f : α → β → Option γ} {k : α} (h : m.WF),
Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.filterMap f m) k =
((Std.DHashMap.Raw.Const.get? m k).pbind fun x h' => f (m.getKey k ⋯) x).get! | true |
Submodule.restrictScalars_mono | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] {s t : Submodule R M},
s ≤ t → Submodule.restrictScalars S s ≤ Submodule.restrictScalars S t | true |
Std.TreeSet.Raw.WF.merge | Std.Data.TreeSet.Raw.WF | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp}, t₁.WF → (t₁.merge t₂).WF | true |
LatticeCon.ker._proof_2 | Mathlib.Order.Lattice.Congruence | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[LatticeHomClass F α β] (f : F) {w x y z : α},
(Setoid.ker ⇑f) w x → (Setoid.ker ⇑f) y z → (Setoid.ker ⇑f) (w ⊓ y) (x ⊓ z) | false |
Field.insepDegree | Mathlib.FieldTheory.SeparableClosure | (F : Type u) → (E : Type v) → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → Cardinal.{v} | true |
Int.emod_add_cancel_left | Init.Data.Int.DivMod.Lemmas | ∀ {m n k i : ℤ}, (i + m) % n = (i + k) % n ↔ m % n = k % n | true |
Std.DTreeMap.Internal.Impl.Ordered | Std.Data.DTreeMap.Internal.Ordered | {α : Type u} → {β : α → Type v} → [Ord α] → Std.DTreeMap.Internal.Impl α β → Prop | true |
Subgroup.le_closure_toSubmonoid | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (S : Set G), Submonoid.closure S ≤ (Subgroup.closure S).toSubmonoid | true |
_private.Mathlib.Algebra.Star.Module.0.IsIdempotentElem.star_iff._simp_1_1 | Mathlib.Algebra.Star.Module | ∀ {R : Type u} {inst : Mul R} [self : StarMul R] (r s : R), star s * star r = star (r * s) | false |
Finite.recOn | Mathlib.Data.Finite.Defs | ∀ {α : Sort u_3} {motive : Finite α → Prop} (t : Finite α), (∀ {n : ℕ} (a : α ≃ Fin n), motive ⋯) → motive t | false |
List.filter_filterMap | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {p : β → Bool} {l : List α},
List.filter p (List.filterMap f l) = List.filterMap (fun x => Option.filter p (f x)) l | true |
Std.HashMap.getElem?_alter | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : Option β → Option β}, (m.alter k f)[k']? = if (k == k') = true then f m[k]? else m[k']? | true |
Module.Basis.reindexFinsetRange_self | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_10} {R : Type u_11} {M : Type u_12} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) [inst_3 : Fintype ι] [inst_4 : DecidableEq M] (i : ι)
(h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯), b.reindexFinsetRange ⟨b i, h⟩ = b i | true |
Lean.Lsp.TextDocumentRegistrationOptions.mk.injEq | Lean.Data.Lsp.Basic | ∀ (documentSelector? documentSelector?_1 : Option Lean.Lsp.DocumentSelector),
({ documentSelector? := documentSelector? } = { documentSelector? := documentSelector?_1 }) =
(documentSelector? = documentSelector?_1) | true |
Lean.Elab.PartialTermInfo.mk | Lean.Elab.InfoTree.Types | Lean.Elab.ElabInfo → Lean.LocalContext → Option Lean.Expr → Lean.Elab.PartialTermInfo | true |
Aesop.Script.DynStructureM.Context.noConfusion | Aesop.Script.StructureDynamic | {P : Sort u} →
{t t' : Aesop.Script.DynStructureM.Context} → t = t' → Aesop.Script.DynStructureM.Context.noConfusionType P t t' | false |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.Proof.0.Lean.Meta.Grind.Arith.Linear.mkCommRingLinOrdThmPrefix | Lean.Meta.Tactic.Grind.Arith.Linear.Proof | Lean.Name → Lean.Meta.Grind.Arith.Linear.ProofM Lean.Expr | true |
MeasureTheory.Measure.count.isFiniteMeasure | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [Finite α], MeasureTheory.IsFiniteMeasure MeasureTheory.Measure.count | true |
Polynomial.map_prod | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S) {ι : Type u_1}
(g : ι → Polynomial R) (s : Finset ι), Polynomial.map f (∏ i ∈ s, g i) = ∏ i ∈ s, Polynomial.map f (g i) | true |
IsLocalRing.specializes_closedPoint | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : IsLocalRing R] (x : PrimeSpectrum R), x ⤳ IsLocalRing.closedPoint R | true |
Encodable.encodeSum | Mathlib.Logic.Encodable.Basic | {α : Type u_1} → {β : Type u_2} → [Encodable α] → [Encodable β] → α ⊕ β → ℕ | true |
conjneg_neg'._simp_1 | Mathlib.Algebra.Order.Star.Conjneg | ∀ {G : Type u_1} {R : Type u_2} [inst : AddGroup G] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[inst_3 : StarRing R] [StarOrderedRing R] {f : G → R}, (conjneg f < 0) = (f < 0) | false |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {y : α} [inst_1 : DecidableLT α] [inst_2 : LocallyFiniteOrder α]
(a b : { x // y < x }), b ∈ Finset.subtype (fun x => y < x) (Finset.Ioo y ↑a) ↔ b < a | false |
unitOfInvertible | Mathlib.Algebra.Group.Invertible.Basic | {α : Type u} → [inst : Monoid α] → (a : α) → [Invertible a] → αˣ | true |
_private.Mathlib.Control.Fix.0.Part.Fix.approx.match_1.splitter | Mathlib.Control.Fix | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((i : ℕ) → motive i.succ) → motive x | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.match_1 | Lean.Elab.MacroArgUtil | (motive : Option Lean.Ident → Sort u_1) →
(id? : Option Lean.Ident) → ((id : Lean.Ident) → motive (some id)) → (Unit → motive none) → motive id? | false |
Batteries.Tactic.TransRelation.implies.sizeOf_spec | Batteries.Tactic.Trans | ∀ (name : Lean.Name) (bi : Lean.BinderInfo),
sizeOf (Batteries.Tactic.TransRelation.implies name bi) = 1 + sizeOf name + sizeOf bi | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.elabReorder.match_7 | Mathlib.Tactic.Translate.Reorder | (motive : MProd (Array (ℕ × Mathlib.Tactic.Translate.Reorder)) (List { l // 2 ≤ l.length }) → Sort u_1) →
(r : MProd (Array (ℕ × Mathlib.Tactic.Translate.Reorder)) (List { l // 2 ≤ l.length })) →
((argReorders : Array (ℕ × Mathlib.Tactic.Translate.Reorder)) →
(perm : List { l // 2 ≤ l.length }) → motive ⟨argReorders, perm⟩) →
motive r | false |
NonUnitalNonAssocRing.toHasDistribNeg._proof_4 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a b : α), -a * b = -(a * b) | false |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.ImportState.minImports._default | Mathlib.Tactic.Linter.MinImports | Lean.NameSet | false |
SimpleGraph.CompleteEquipartiteSubgraph.card_verts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (K : G.CompleteEquipartiteSubgraph r t), K.verts.card = r * t | true |
CategoryTheory.Functor.commShiftOp_iso_eq | Mathlib.CategoryTheory.Shift.Opposite | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
[inst_5 : F.CommShift A] (a : A),
CategoryTheory.Functor.commShiftIso (CategoryTheory.OppositeShift.functor A F) a =
(CategoryTheory.NatIso.op (CategoryTheory.Functor.commShiftIso F a)).symm | true |
LinearOrder.liftWithOrd._proof_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : LinearOrder β] [inst_1 : Ord α] (f : α → β),
(∀ (a b : α), compare a b = compare (f a) (f b)) → ∀ (x x_1 : α), compare (f x) (f x_1) = compare x x_1 | false |
Part.inv_mem_inv | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Inv α] (a : Part α), ∀ ma ∈ a, ma⁻¹ ∈ a⁻¹ | true |
Std.Time.Timestamp.subWeeks | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Week.Offset → Std.Time.Timestamp | true |
Module.fgSystem.equiv_comp_of | Mathlib.Algebra.Colimit.Finiteness | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Submodule R M)] (N : { N // N.FG }),
↑(Module.fgSystem.equiv R M) ∘ₗ Module.DirectLimit.of R { N // N.FG } (fun i => ↥↑i) (Module.fgSystem R M) N =
(↑N).subtype | true |
Std.IterM.drain_eq_map_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β},
it.drain = (fun x => PUnit.unit) <$> it.toList | true |
groupHomology.instPreservesZeroMorphismsRepChainComplexModuleCatNatChainsFunctor | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Group G], (groupHomology.chainsFunctor k G).PreservesZeroMorphisms | true |
GenContFract.IntFractPair.mapFr.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {K : Type u_1} {β : Type u_2} (f : K → β) (gp : GenContFract.IntFractPair K),
GenContFract.IntFractPair.mapFr f gp = { b := gp.b, fr := f gp.fr } | true |
MeasureTheory.Measure.InnerRegularWRT.eq_of_innerRegularWRT_of_forall_eq | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop}
{ν : MeasureTheory.Measure α},
μ.InnerRegularWRT p q → ν.InnerRegularWRT p q → (∀ (U : Set α), p U → μ U = ν U) → ∀ {U : Set α}, q U → μ U = ν U | true |
Module.Relations.Solution.congr_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution' : relations.Solution M},
solution = solution' → ∀ (g : relations.G), solution.var g = solution'.var g | true |
_private.Lean.Server.Logging.0.Lean.Server.Logging.LogEntry.mk.inj | Lean.Server.Logging | ∀ {time : Std.Time.ZonedDateTime} {direction : Lean.JsonRpc.MessageDirection} {kind : Lean.JsonRpc.MessageKind}
{msg : Lean.JsonRpc.Message} {time_1 : Std.Time.ZonedDateTime} {direction_1 : Lean.JsonRpc.MessageDirection}
{kind_1 : Lean.JsonRpc.MessageKind} {msg_1 : Lean.JsonRpc.Message},
{ time := time, direction := direction, kind := kind, msg := msg } =
{ time := time_1, direction := direction_1, kind := kind_1, msg := msg_1 } →
time = time_1 ∧ direction = direction_1 ∧ kind = kind_1 ∧ msg = msg_1 | true |
BoxIntegral.Box.mem_mk._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {l u x : ι → ℝ} {H : ∀ (i : ι), l i < u i},
(x ∈ { lower := l, upper := u, lower_lt_upper := H }) = ∀ (i : ι), x i ∈ Set.Ioc (l i) (u i) | false |
IO.FS.SystemTime.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.FS.SystemTime} → t = t' → IO.FS.SystemTime.noConfusionType P t t' | false |
CochainComplex.HomComplex.CohomologyClass.mk_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ), CochainComplex.HomComplex.CohomologyClass.mk 0 = 0 | true |
Finsupp.prod_finset_sum_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {ι : Type u_2} {M : Type u_8} {N : Type u_10} [inst : AddCommMonoid M] [inst_1 : CommMonoid N]
{s : Finset ι} {g : ι → α →₀ M} {h : α → M → N},
(∀ (a : α), h a 0 = 1) →
(∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂) → ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h | true |
CategoryTheory.Limits.WalkingParallelFamily.Hom.line.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{P : Sort u} →
{a a' : J} →
CategoryTheory.Limits.WalkingParallelFamily.Hom.line a = CategoryTheory.Limits.WalkingParallelFamily.Hom.line a' →
(a ≍ a' → P) → P | false |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1 | Lean.Widget.Types | Type | false |
InformationTheory.klDiv_eq_integral_klFun | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν],
InformationTheory.klDiv μ ν =
if μ.AbsolutelyContinuous ν ∧ MeasureTheory.Integrable (MeasureTheory.llr μ ν) μ then
ENNReal.ofReal (∫ (x : α), InformationTheory.klFun (μ.rnDeriv ν x).toReal ∂ν)
else ⊤ | true |
Fin.reduceCastSucc._regBuiltin.Fin.reduceCastSucc.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin.2550739679._hygCtx._hyg.17 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Fin | IO Unit | false |
CategoryTheory.Localization.Monoidal.triangle | Mathlib.CategoryTheory.Localization.Monoidal.Basic | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] {L : CategoryTheory.Functor C D}
{W : CategoryTheory.MorphismProperty C} [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} {ε : L.obj (CategoryTheory.MonoidalCategoryStruct.tensorUnit C) ≅ unit}
(X Y : CategoryTheory.LocalizedMonoidal L W ε),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.associator X
(CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.LocalizedMonoidal L W ε)) Y).hom
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft X (CategoryTheory.MonoidalCategoryStruct.leftUnitor Y).hom) =
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom Y | true |
_private.Mathlib.Order.Atoms.0.bot_covBy_iff._simp_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (⊥ < a) = (a ≠ ⊥) | false |
Std.Internal.List.getKey!_map | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [EquivBEq α] [inst_2 : Inhabited α]
{f : (a : α) → β a → γ a} {l : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey! k (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l) = Std.Internal.List.getKey! k l | true |
Lean.Lsp.instToJsonRpcReleaseParams.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.RpcReleaseParams → Lean.Json | true |
Matrix.trace_fin_one | Mathlib.LinearAlgebra.Matrix.Trace | ∀ {R : Type u_6} [inst : AddCommMonoid R] (A : Matrix (Fin 1) (Fin 1) R), A.trace = A 0 0 | true |
Complex.norm_ratCast | Mathlib.Analysis.Complex.Norm | ∀ (q : ℚ), ‖↑q‖ = |↑q| | true |
_private.Std.Data.DHashMap.Internal.WF.0.Std.Internal.List.interSmallerFn.eq_1 | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] (l sofar : List ((a : α) × β a)) (k : α),
Std.Internal.List.interSmallerFn l sofar k =
match Std.Internal.List.getEntry? k l with
| some kv' => Std.Internal.List.insertEntry kv'.fst kv'.snd sofar
| none => sofar | true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Real.rpow_def_of_nonneg._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | false |
IsOpenMap.functor._proof_2 | Mathlib.Topology.Category.TopCat.Opens | ∀ {X Y : TopCat} {f : X ⟶ Y} (hf : IsOpenMap ⇑(CategoryTheory.ConcreteCategory.hom f))
{X_1 Y_1 Z : TopologicalSpace.Opens ↑X} (f_1 : X_1 ⟶ Y_1) (g : Y_1 ⟶ Z),
IsOpenMap.functorMap ⋯ ⋯ ⋯ =
CategoryTheory.CategoryStruct.comp (IsOpenMap.functorMap ⋯ ⋯ ⋯) (IsOpenMap.functorMap ⋯ ⋯ ⋯) | false |
CategoryTheory.Mat_.instAddCommGroupHom | Mathlib.CategoryTheory.Preadditive.Mat | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Preadditive C] → (M N : CategoryTheory.Mat_ C) → AddCommGroup (M ⟶ N) | true |
Lean.Elab.PartialTermInfo.casesOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.PartialTermInfo → Sort u} →
(t : Lean.Elab.PartialTermInfo) →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
motive { toElabInfo := toElabInfo, lctx := lctx, expectedType? := expectedType? }) →
motive t | false |
Nat.SOM.Poly.append_denote | Init.Data.Nat.SOM | ∀ (ctx : Nat.Linear.Context) (p₁ p₂ : Nat.SOM.Poly),
Nat.SOM.Poly.denote ctx (p₁ ++ p₂) = Nat.SOM.Poly.denote ctx p₁ + Nat.SOM.Poly.denote ctx p₂ | true |
Subgroup.subgroupOf_map_powMonoidHom_eq_range | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {M : Type u_6} [inst : CommGroup M] (S : Subgroup M) (n : ℕ),
(Subgroup.map (powMonoidHom n) S).subgroupOf S = (powMonoidHom n).range | true |
_private.Init.Data.List.MinMax.0.List.max?_attach._simp_1_4 | Init.Data.List.MinMax | ∀ {α : Sort u} {p : α → Prop} {a1 a2 : { x // p x }}, (a1 = a2) = (↑a1 = ↑a2) | false |
_private.Lean.Compiler.LCNF.Specialize.0.PSigma.casesOn._arg_pusher | Lean.Compiler.LCNF.Specialize | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → rel t y → β_1 y) → motive t) t mk fun y h => f y) =
PSigma.casesOn t fun fst snd => mk fst snd fun y h => f y | false |
IsDedekindDomain.HeightOneSpectrum.equivPrimesOver | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | {A : Type u_4} →
[inst : CommRing A] →
{p : Ideal A} →
[hpm : p.IsMaximal] →
(B : Type u_5) →
[inst_1 : CommRing B] →
[IsDedekindDomain B] →
[inst_3 : Algebra A B] →
[IsDomain A] →
[Module.IsTorsionFree A B] →
p ≠ 0 → { v // v.asIdeal ∣ Ideal.map (algebraMap A B) p } ≃ ↑(p.primesOver B) | true |
_private.Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas.0.ZMod.sum_Ico_eq_card_lt | Mathlib.NumberTheory.LegendreSymbol.GaussEisensteinLemmas | ∀ {p q : ℕ},
∑ a ∈ Finset.Ico 1 (p / 2).succ, a * q / p =
{x ∈ Finset.Ico 1 (p / 2).succ ×ˢ Finset.Ico 1 (q / 2).succ | x.2 * p ≤ x.1 * q}.card | true |
LawfulMonadStateOf.set_bind_modifyGet_bind | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α β : Type u_1} (s : σ) (f : σ → α × σ) (mx : α → m β),
(do
set s
let x ← modifyGet f
mx x) =
do
set (f s).2
mx (f s).1 | true |
TopologicalSpace.Opens.toTopCat_map | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat) {U V : TopologicalSpace.Opens ↑X} {f : U ⟶ V} {x : ↑X} {h : x ∈ U},
(CategoryTheory.ConcreteCategory.hom ((TopologicalSpace.Opens.toTopCat X).map f)) ⟨x, h⟩ = ⟨x, ⋯⟩ | true |
Mathlib.Tactic.Ring.natCast_mul | Mathlib.Tactic.Ring.Common | ∀ {R : Type u_1} [inst : CommSemiring R] {b₁ b₃ : R} {a₁ a₃ : ℕ} (a₂ : ℕ),
↑a₁ = b₁ → ↑a₃ = b₃ → ↑(a₁ ^ a₂ * a₃) = b₁ ^ a₂ * b₃ | true |
AlgebraicGeometry.Scheme.Cover.exists_lift_trans_eq | Mathlib.AlgebraicGeometry.Cover.Directed | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} {X : AlgebraicGeometry.Scheme}
(𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X)
[inst : CategoryTheory.Category.{v_1, u_1} 𝒰.I₀] [inst_1 : 𝒰.LocallyDirected] {i j : 𝒰.I₀}
(x : ↥(CategoryTheory.Limits.pullback (𝒰.f i) (𝒰.f j))),
∃ k hki hkj y, (CategoryTheory.Limits.pullback.lift (𝒰.trans hki) (𝒰.trans hkj) ⋯) y = x | true |
_private.Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit.0.CategoryTheory.coherentTopology.preimage._proof_3 | Mathlib.CategoryTheory.Sites.Coherent.SequentialLimit | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Preregular C]
[inst_2 : CategoryTheory.FinitaryExtensive C]
{F : CategoryTheory.Functor ℕᵒᵖ (CategoryTheory.Sheaf (CategoryTheory.coherentTopology C) (Type u_2))},
(∀ (n : ℕ), CategoryTheory.Sheaf.IsLocallySurjective (F.map (CategoryTheory.homOfLE ⋯).op)) →
∀ (n : ℕ) (x : Nat.below n.succ),
∃ X' φ,
∃ (_ : CategoryTheory.EffectiveEpi φ),
∃ x_2,
(F.map (CategoryTheory.homOfLE ⋯).op).hom.app (Opposite.op X') x_2 =
(F.obj (Opposite.op n)).obj.map φ.op x.1.snd | false |
PointedCone.maxTensorProduct._proof_2 | Mathlib.Geometry.Convex.Cone.TensorProduct | ∀ {R : Type u_1} [inst : CommRing R], SMulCommClass R R R | false |
DivInvMonoid.div._default | Mathlib.Algebra.Group.Defs | {G : Type u} →
(mul : G → G → G) →
(∀ (a b c : G), a * b * c = a * (b * c)) →
(one : G) →
(∀ (a : G), 1 * a = a) →
(∀ (a : G), a * 1 = a) →
(npow : ℕ → G → G) →
(∀ (x : G), npow 0 x = 1) → (∀ (n : ℕ) (x : G), npow (n + 1) x = npow n x * x) → (G → G) → G → G → G | false |
Subsemigroup.unop_eq_bot._simp_2 | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S : Subsemigroup Mᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) | false |
ContinuousCohomology.kerHomogeneousCochainsZeroEquiv._proof_17 | Mathlib.Algebra.Category.ContinuousCohomology.Basic | ∀ (R : Type u_3) (G : Type u_1) [inst : CommRing R] [inst_1 : Group G] [inst_2 : TopologicalSpace R]
[inst_3 : TopologicalSpace G] [inst_4 : IsTopologicalGroup G] (X : Action (TopModuleCat R) G) (n : ℕ) (hn : n = 1)
(x : ↑((ContinuousCohomology.invariants R G).obj X).toModuleCat) (g : G),
(TopModuleCat.Hom.hom (X.ρ g)) (↑↑⟨⟨(ContinuousLinearMap.const R G) ↑x, ⋯⟩, ⋯⟩ 1) =
↑↑⟨⟨(ContinuousLinearMap.const R G) ↑x, ⋯⟩, ⋯⟩ 1 | false |
LightProfinite.«termℕ∪{∞}» | Mathlib.Topology.Category.LightProfinite.Sequence | Lean.ParserDescr | true |
CategoryTheory.Functor.sheafPushforwardContinuousIso_hom | Mathlib.CategoryTheory.Sites.Continuous | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F F' : CategoryTheory.Functor C D} (e : F ≅ F') (A : Type u) [inst_2 : CategoryTheory.Category.{t, u} A]
(J : CategoryTheory.GrothendieckTopology C) (K : CategoryTheory.GrothendieckTopology D) [inst_3 : F.IsContinuous J K]
[inst_4 : F'.IsContinuous J K],
(CategoryTheory.Functor.sheafPushforwardContinuousIso e A J K).hom =
CategoryTheory.Functor.sheafPushforwardContinuousNatTrans e.inv A J K | true |
Std.TreeMap.getKey!_eq_get!_getKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α]
{a : α}, t.getKey! a = (t.getKey? a).get! | true |
Lean.Meta.CaseValuesSubgoal.mk.injEq | Lean.Meta.Match.CaseValues | ∀ (mvarId : Lean.MVarId) (newHs : Array Lean.FVarId) (subst : Lean.Meta.FVarSubst) (mvarId_1 : Lean.MVarId)
(newHs_1 : Array Lean.FVarId) (subst_1 : Lean.Meta.FVarSubst),
({ mvarId := mvarId, newHs := newHs, subst := subst } = { mvarId := mvarId_1, newHs := newHs_1, subst := subst_1 }) =
(mvarId = mvarId_1 ∧ newHs = newHs_1 ∧ subst = subst_1) | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.Const.minKey?_modifyKey._simp_1_3 | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α] {k : α}
{l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
(Std.Internal.List.minKey? l = some k) =
(Std.Internal.List.getKey? k l = some k ∧
∀ (k' : α), Std.Internal.List.containsKey k' l = true → (compare k k').isLE = true) | false |
MeasureTheory.Egorov.tendstoUniformlyOn_diff_iUnionNotConvergentSeq | Mathlib.MeasureTheory.Function.Egorov | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} {m : MeasurableSpace α} [inst : PseudoEMetricSpace β]
{μ : MeasureTheory.Measure α} {s : Set α} {ε : ℝ} {f : ι → α → β} {g : α → β} [inst_1 : SemilatticeSup ι]
[inst_2 : Nonempty ι] [inst_3 : Countable ι] (hε : 0 < ε) (hf : ∀ (n : ι), Measurable fun a => edist (f n a) (g a))
(hsm : MeasurableSet s) (hs : μ s ≠ ⊤)
(hfg : ∀ᵐ (x : α) ∂μ, x ∈ s → Filter.Tendsto (fun n => f n x) Filter.atTop (nhds (g x))),
TendstoUniformlyOn f g Filter.atTop (s \ MeasureTheory.Egorov.iUnionNotConvergentSeq hε hf hsm hs hfg) | true |
PosNum.cmp_swap | Mathlib.Data.Num.Lemmas | ∀ (m n : PosNum), (m.cmp n).swap = n.cmp m | true |
AddEquiv.ext_int | Mathlib.Data.Int.Cast.Lemmas | ∀ {A : Type u_5} [inst : AddMonoid A] {f g : ℤ ≃+ A}, f 1 = g 1 → f = g | true |
Lean.Lsp.DocumentColorOptions.mk.inj | Lean.Data.Lsp.LanguageFeatures | ∀ {toWorkDoneProgressOptions toWorkDoneProgressOptions_1 : Lean.Lsp.WorkDoneProgressOptions},
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions } =
{ toWorkDoneProgressOptions := toWorkDoneProgressOptions_1 } →
toWorkDoneProgressOptions = toWorkDoneProgressOptions_1 | true |
Polygon.HasNondegenerateVertices.hasNondegenerateEdges | Mathlib.Geometry.Polygon.Basic | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_3} {n : ℕ} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
[inst_3 : AddTorsor V P] [inst_4 : NeZero n] [Nontrivial R] {poly : Polygon P n},
Polygon.HasNondegenerateVertices R poly → poly.HasNondegenerateEdges | true |
AlgebraicGeometry.ExistsHomHomCompEqCompAux.mk.noConfusion | Mathlib.AlgebraicGeometry.AffineTransitionLimit | {I : Type u} →
{inst : CategoryTheory.Category.{u, u} I} →
{S X : AlgebraicGeometry.Scheme} →
{D : CategoryTheory.Functor I AlgebraicGeometry.Scheme} →
{t : D ⟶ (CategoryTheory.Functor.const I).obj S} →
{f : X ⟶ S} →
{P : Sort u_1} →
{c : CategoryTheory.Limits.Cone D} →
{hc : CategoryTheory.Limits.IsLimit c} →
{i : I} →
{a : D.obj i ⟶ X} →
{ha : t.app i = CategoryTheory.CategoryStruct.comp a f} →
{b : D.obj i ⟶ X} →
{hb : t.app i = CategoryTheory.CategoryStruct.comp b f} →
{hab :
CategoryTheory.CategoryStruct.comp (c.π.app i) a =
CategoryTheory.CategoryStruct.comp (c.π.app i) b} →
{𝒰S : S.OpenCover} →
{h𝒰S : ∀ (i : 𝒰S.I₀), AlgebraicGeometry.IsAffine (𝒰S.X i)} →
{𝒰X :
(i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).X i).OpenCover} →
{h𝒰X :
∀ (i : (CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f 𝒰S).I₀)
(j : (𝒰X i).I₀), AlgebraicGeometry.IsAffine ((𝒰X i).X j)} →
{c' : CategoryTheory.Limits.Cone D} →
{hc' : CategoryTheory.Limits.IsLimit c'} →
{i' : I} →
{a' : D.obj i' ⟶ X} →
{ha' : t.app i' = CategoryTheory.CategoryStruct.comp a' f} →
{b' : D.obj i' ⟶ X} →
{hb' : t.app i' = CategoryTheory.CategoryStruct.comp b' f} →
{hab' :
CategoryTheory.CategoryStruct.comp (c'.π.app i') a' =
CategoryTheory.CategoryStruct.comp (c'.π.app i') b'} →
{𝒰S' : S.OpenCover} →
{h𝒰S' : ∀ (i : 𝒰S'.I₀), AlgebraicGeometry.IsAffine (𝒰S'.X i)} →
{𝒰X' :
(i :
(CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f
𝒰S').I₀) →
((CategoryTheory.Precoverage.ZeroHypercover.pullback₁ f
𝒰S').X
i).OpenCover} →
{h𝒰X' :
∀
(i :
(CategoryTheory.Precoverage.ZeroHypercover.pullback₁
f 𝒰S').I₀)
(j : (𝒰X' i).I₀),
AlgebraicGeometry.IsAffine ((𝒰X' i).X j)} →
{ c := c, hc := hc, i := i, a := a, ha := ha, b := b,
hb := hb, hab := hab, 𝒰S := 𝒰S, h𝒰S := h𝒰S,
𝒰X := 𝒰X, h𝒰X := h𝒰X } =
{ c := c', hc := hc', i := i', a := a', ha := ha',
b := b', hb := hb', hab := hab', 𝒰S := 𝒰S',
h𝒰S := h𝒰S', 𝒰X := 𝒰X', h𝒰X := h𝒰X' } →
(c ≍ c' →
hc ≍ hc' →
i ≍ i' →
a ≍ a' → b ≍ b' → 𝒰S ≍ 𝒰S' → 𝒰X ≍ 𝒰X' → P) →
P | false |
Subarray.foldrM | Init.Data.Array.Subarray | {α : Type u} → {β : Type v} → {m : Type v → Type w} → [Monad m] → (α → β → m β) → β → Subarray α → m β | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.