name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Lean.Widget.RpcEncodablePacket.strict.«_@».Lean.Widget.InteractiveDiagnostic.2157017296._hygCtx._hyg.1.noConfusion | Lean.Widget.InteractiveDiagnostic | {P : Sort u} →
{a a' : Lean.Json} →
Lean.Widget.RpcEncodablePacket.strict✝ a = Lean.Widget.RpcEncodablePacket.strict✝ a' → (a = a' → P) → P | false |
Lean.Meta.instReprSimpCongrTheorems.repr | Lean.Meta.Tactic.Simp.SimpCongrTheorems | Lean.Meta.SimpCongrTheorems → ℕ → Std.Format | true |
ModuleCat.extendScalars_assoc' | Mathlib.Algebra.Category.ModuleCat.ChangeOfRings | ∀ {R₁ R₂ R₃ R₄ : Type u₁} [inst : CommRing R₁] [inst_1 : CommRing R₂] [inst_2 : CommRing R₃] [inst_3 : CommRing R₄]
(f₁₂ : R₁ →+* R₂) (f₂₃ : R₂ →+* R₃) (f₃₄ : R₃ →+* R₄),
CategoryTheory.CategoryStruct.comp (ModuleCat.extendScalarsComp (f₂₃.comp f₁₂) f₃₄).hom
(CategoryTheory.CategoryStruct.comp
(Catego... | true |
measurableEmbedding_mulLeft₀ | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] [inst_1 : MeasurableSpace G₀] [MeasurableMul G₀] {g : G₀},
g ≠ 0 → MeasurableEmbedding fun x => g * x | true |
_private.Mathlib.CategoryTheory.Equivalence.0.CategoryTheory.Functor.IsEquivalence.mk'._proof_1_1 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] {F : CategoryTheory.Functor C D} (G : CategoryTheory.Functor D C)
(η : CategoryTheory.Functor.id C ≅ F.comp G) (ε : G.comp F ≅ CategoryTheory.Functor.id D), F.IsEquivalence | false |
Qq.Impl.PatVarDecl.fvar | Qq.MatchImpl | (decl : Qq.Impl.PatVarDecl) →
have a := decl.fvarTy;
Q(«$a») | true |
_private.Mathlib.Combinatorics.SimpleGraph.Matching.0.SimpleGraph.Subgraph.IsMatching.iSup._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {α : Type u} {s t : Set α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | false |
Cardinal.lift_eq_aleph1 | Mathlib.SetTheory.Cardinal.Aleph | ∀ {c : Cardinal.{u}}, Cardinal.lift.{v, u} c = Cardinal.aleph 1 ↔ c = Cardinal.aleph 1 | true |
List.forIn'.loop._proof_1 | Init.Data.List.Control | ∀ {α : Type u_1} (as : List α) (a : α) (as' : List α), (∃ bs, bs ++ a :: as' = as) → ∃ bs, bs ++ as' = as | false |
groupHomology.isBoundary₁_of_mem_boundaries₁ | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G A : Type u} [inst : CommRing k] [inst_1 : Group G] [inst_2 : AddCommGroup A] [inst_3 : Module k A]
[inst_4 : DistribMulAction G A] [inst_5 : SMulCommClass G k A],
∀ x ∈ groupHomology.boundaries₁ (Rep.ofDistribMulAction k G A), groupHomology.IsBoundary₁ x | true |
CategoryTheory.FreeBicategory.Hom₂.whisker_left.sizeOf_spec | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u} [inst : Quiver B] [inst_1 : SizeOf B] {a b c : CategoryTheory.FreeBicategory B} (f : a ⟶ b) {g h : b ⟶ c}
(η : CategoryTheory.FreeBicategory.Hom₂ g h),
sizeOf (CategoryTheory.FreeBicategory.Hom₂.whisker_left f η) =
1 + sizeOf a + sizeOf b + sizeOf c + sizeOf f + sizeOf g + sizeOf h + sizeOf η | true |
UInt32.toFin_mul | Init.Data.UInt.Lemmas | ∀ (a b : UInt32), (a * b).toFin = a.toFin * b.toFin | true |
AlgebraicGeometry.Scheme.Pullback.t_fst_snd | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {X Y Z : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) (f : X ⟶ Z) (g : Y ⟶ Z)
[inst : ∀ (i : 𝒰.I₀), CategoryTheory.Limits.HasPullback (CategoryTheory.CategoryStruct.comp (𝒰.f i) f) g]
(i j : 𝒰.I₀),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Pullback.t 𝒰 f g i j)
(CategoryTheory.Categ... | true |
Lean.Elab.Term.elabProp._regBuiltin.Lean.Elab.Term.elabProp.declRange_3 | Lean.Elab.BuiltinTerm | IO Unit | false |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.State._sizeOf_1 | Lean.Compiler.LCNF.ExplicitRC | Lean.Compiler.LCNF.CollectDerivedValInfo.State✝ → ℕ | false |
Lean.Meta.Grind.CheckResult.closed.elim | Lean.Meta.Tactic.Grind.CheckResult | {motive : Lean.Meta.Grind.CheckResult → Sort u} →
(t : Lean.Meta.Grind.CheckResult) → t.ctorIdx = 3 → motive Lean.Meta.Grind.CheckResult.closed → motive t | false |
_private.Mathlib.Algebra.Category.Ring.Colimits.0.RingCat.Colimits.descFunLift.match_1.eq_4 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J RingCat)
(motive : RingCat.Colimits.Prequotient F → Sort u_2) (x : RingCat.Colimits.Prequotient F)
(h_1 : (j : J) → (x : ↑(F.obj j)) → motive (RingCat.Colimits.Prequotient.of j x))
(h_2 : Unit → motive RingCat.Colimits.Prequoti... | true |
instReprUInt64 | Init.Data.Repr | Repr UInt64 | true |
CharP.orderOf_eq_two_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {R : Type u_6} [inst : Ring R] [Nontrivial R] [NoZeroDivisors R] (p : ℕ),
p ≠ 2 → ∀ [CharP R p] {x : R}, orderOf x = 2 ↔ x = -1 | true |
Polynomial.aeval_conj | Mathlib.Analysis.RCLike.Lemmas | ∀ {K : Type u_1} [inst : RCLike K] (p : Polynomial ℝ) (z : K),
(Polynomial.aeval ((starRingEnd K) z)) p = (starRingEnd K) ((Polynomial.aeval z) p) | true |
MulOpposite.instCommCStarAlgebra._proof_3 | Mathlib.Analysis.CStarAlgebra.Classes | ∀ {A : Type u_1} [inst : CommCStarAlgebra A], StarModule ℂ Aᵐᵒᵖ | false |
CategoryTheory.GrothendieckTopology.Subcanonical.of_le | Mathlib.CategoryTheory.Sites.Canonical | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J K : CategoryTheory.GrothendieckTopology C},
J ≤ K → ∀ [K.Subcanonical], J.Subcanonical | true |
ZNum.rec | Mathlib.Data.Num.Basic | {motive : ZNum → Sort u} →
motive ZNum.zero → ((a : PosNum) → motive (ZNum.pos a)) → ((a : PosNum) → motive (ZNum.neg a)) → (t : ZNum) → motive t | false |
Std.Time.Minute.instNegOffset._aux_1 | Std.Time.Time.Unit.Minute | Std.Time.Minute.Offset → Std.Time.Minute.Offset | false |
CategoryTheory.LocalizerMorphism.RightResolution.Hom.noConfusion | Mathlib.CategoryTheory.Localization.Resolution | {P : Sort u} →
{C₁ : Type u_1} →
{C₂ : Type u_2} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_2, u_2} C₂} →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
{Φ : CategoryTheory.Local... | false |
Nat.le_sub_of_add_le' | Init.Data.Nat.Lemmas | ∀ {n k m : ℕ}, m + n ≤ k → n ≤ k - m | true |
Mathlib.Tactic.Translate.TranslateData.mk.noConfusion | Mathlib.Tactic.Translate.Core | {P : Sort u} →
{ignoreArgsAttr : Lean.NameMapExtension (List ℕ)} →
{doTranslateAttr : Lean.NameMapExtension Bool} →
{unfoldBoundaries? : Option Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaryExt} →
{translations : Lean.NameMapExtension Mathlib.Tactic.Translate.TranslationInfo} →
{attrName : L... | false |
Action.instMonoidalForget._proof_2 | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (G : Type u_3) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] {X Y : Action V G} (f : X ⟶ Y) (X' : Action V G),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight ((Action.forget V G).map f) ((... | false |
AlgebraicIndependent.to_subtype_range | Mathlib.RingTheory.AlgebraicIndependent.Basic | ∀ {ι : Type u} {R : Type u_2} {A : Type v} {x : ι → A} [inst : CommRing R] [inst_1 : CommRing A] [inst_2 : Algebra R A],
AlgebraicIndependent R x → AlgebraicIndependent R Subtype.val | true |
Decidable.decide.congr_simp | Init.SimpLemmas | ∀ (p p_1 : Prop), p = p_1 → ∀ {h : Decidable p} [h_1 : Decidable p_1], decide p = decide p_1 | true |
IsLocalization.map_units | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} (S : Type u_2) [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [IsLocalization M S] (y : ↥M), IsUnit ((algebraMap R S) ↑y) | true |
MvPFunctor.B | Mathlib.Data.PFunctor.Multivariate.Basic | {n : ℕ} → (self : MvPFunctor.{u} n) → self.A → TypeVec.{u} n | true |
Real.cos_sub_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ), Real.cos (x - 2 * Real.pi) = Real.cos x | true |
AlgebraicGeometry.Scheme.Hom.asFiberHom._proof_1 | Mathlib.AlgebraicGeometry.Fiber | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (x : ↥X),
CategoryTheory.Limits.HasPullback f (Y.fromSpecResidueField (f x)) | false |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_536 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α)
(h :
List.findIdxNth (fun x => decide (x = w)) [g (g a)] (List.idxOfNth w [g (g a)] 1) + 1 ≤
(List.filter (fun x => decide (x = w)) []).length),
(List.findIdxs (fun x => decide (x = w))
[])[List.findIdxNth (fun x => decid... | false |
_private.Mathlib.Tactic.SuccessIfFailWithMsg.0.Mathlib.Tactic.successIfFailWithMessage.match_4 | Mathlib.Tactic.SuccessIfFailWithMsg | (motive : Option Lean.Syntax → Sort u_1) →
(ref : Option Lean.Syntax) →
((ref : Lean.Syntax) → motive (some ref)) → ((x : Option Lean.Syntax) → motive x) → motive ref | false |
_private.Mathlib.Analysis.CStarAlgebra.ApproximateUnit.0.CFC.monotoneOn_one_sub_one_add_inv_real._proof_1_1 | Mathlib.Analysis.CStarAlgebra.ApproximateUnit | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A] ⦃a : A⦄,
0 ≤ a → ∀ ⦃x : ℝ⦄, x ∈ quasispectrum ℝ a → 0 ≤ x | false |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.guessReorder.decomposePerm._proof_1 | Mathlib.Tactic.Translate.Reorder | ∀ {n : ℕ},
∀ i ∈ 0...n,
∀
(r :
MProd (Option (List { l // 2 ≤ l.length })) (MProd (Vector (Option (Fin n)) n) (List { l // 2 ≤ l.length }))),
i < n | false |
RootPairing.restrictScalars._proof_1 | Mathlib.LinearAlgebra.RootSystem.BaseChange | ∀ {ι : Type u_1} {L : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Field L] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : Module L M] [inst_4 : Module L N] (P : RootPairing ι L M N) (K : Type u_5)
[inst_5 : Field K] [inst_6 : Algebra K L] [P.IsCrystallographic], P.IsValuedIn K | false |
Batteries.RBSet.find?.eq_1 | Batteries.Data.RBMap.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} (t : Batteries.RBSet α cmp) (x : α),
t.find? x = Batteries.RBNode.find? (cmp x) ↑t | true |
_private.Mathlib.Probability.ProductMeasure.0.MeasureTheory.Measure.infinitePi_pi_univ._simp_1_1 | Mathlib.Probability.ProductMeasure | ∀ {α : Type u}, Set.univ.Countable = Countable α | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ediv_toInt_nonpos_of_nonpos_of_nonneg._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ (w : ℕ) {x y : BitVec (w + 1)}, x.toInt ≤ 0 → 0 ≤ y.toInt → ¬x.toInt = 0 → ¬y.toInt = 0 → ¬x.toInt < 0 → False | false |
Submonoid.powers._proof_2 | Mathlib.Algebra.Group.Submonoid.Membership | ∀ {M : Type u_1} [inst : Monoid M], MonoidHomClass (Multiplicative ℕ →* M) (Multiplicative ℕ) M | false |
SSet.Subcomplex.image_preimage_le._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.Subcomplex | ∀ {X Y : SSet} (B : X.Subcomplex) (f : Y ⟶ X), ((B.preimage f).image f ≤ B) = True | false |
Algebra.Presentation.mk.inj | Mathlib.RingTheory.Extension.Presentation.Basic | ∀ {R : Type u} {S : Type v} {ι : Type w} {σ : Type t} {inst : CommRing R} {inst_1 : CommRing S} {inst_2 : Algebra R S}
{toGenerators : Algebra.Generators R S ι} {relation : σ → toGenerators.Ring}
{span_range_relation_eq_ker : Ideal.span (Set.range relation) = toGenerators.ker}
{toGenerators_1 : Algebra.Generators... | true |
selfAdjoint.unitarySelfAddISMul._proof_5 | Mathlib.Analysis.CStarAlgebra.Unitary.Span | ∀ {A : Type u_1} [inst : CStarAlgebra A], SMulCommClass ℝ A A | false |
Lean.Expr.isHEq | Lean.Util.Recognizers | Lean.Expr → Bool | true |
Filter.IsBoundedUnder.bddAbove_range_of_cofinite | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder β] [IsDirectedOrder β] {f : α → β},
Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) Filter.cofinite f → BddAbove (Set.range f) | true |
Lean.Meta.Grind.Order.ProofInfo.recOn | Lean.Meta.Tactic.Grind.Order.Types | {motive : Lean.Meta.Grind.Order.ProofInfo → Sort u} →
(t : Lean.Meta.Grind.Order.ProofInfo) →
((w : Lean.Meta.Grind.Order.NodeId) →
(k : Lean.Meta.Grind.Order.Weight) → (proof : Lean.Expr) → motive { w := w, k := k, proof := proof }) →
motive t | false |
String.head_toList | Init.Data.String.Basic | ∀ {b : String} {h : b.toList ≠ []}, b.toList.head h = b.toByteArray.utf8DecodeChar 0 ⋯ | true |
lt_map_inv_iff | Mathlib.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : EquivLike F α β]
[OrderIsoClass F α β] (f : F) {a : α} {b : β}, a < EquivLike.inv f b ↔ f a < b | true |
Lean.Elab.Tactic.filterSuggestionsAndLocalsFromGrindConfig | Lean.Elab.Tactic.Grind.Main | Lean.TSyntax `Lean.Parser.Tactic.optConfig → Lean.TSyntax `Lean.Parser.Tactic.optConfig | true |
_private.Init.Data.String.Basic.0.String.startPos_eq_endPos_iff._simp_1_1 | Init.Data.String.Basic | ∀ {s : String}, (s = "") = (s.utf8ByteSize = 0) | false |
OrderDual.isOrderedAddCancelMonoid | Mathlib.Algebra.Order.Monoid.OrderDual | ∀ {α : Type u} [inst : AddCommMonoid α] [inst_1 : Preorder α] [IsOrderedCancelAddMonoid α], IsOrderedCancelAddMonoid αᵒᵈ | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.analyzeAppStagedCore.match_8 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | (motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State → Sort u_1) →
(__discr : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.App.State) →
((bottomUps higherOrders funBinders provideds : Array Bool) →
(namedArgs : Array Lean.Name) →
motive
{ bottomUps := bottomUps, higherO... | false |
SimpleGraph.neighborFinset_eq_filter | Mathlib.Combinatorics.SimpleGraph.Finite | ∀ {V : Type u_1} (G : SimpleGraph V) [inst : Fintype V] {v : V} [inst_1 : DecidableRel G.Adj],
G.neighborFinset v = {w | G.Adj v w} | true |
Std.Rio.pairwise_toList_ne | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rio α} [inst : LT α] [inst_1 : DecidableLT α] [inst_2 : Std.PRange.Least? α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.PRange.LawfulUpwardEnumerable α]
[Std.PRange.LawfulUpwardEnumerableLT α] [Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.Rxo.IsAlwaysFinite α], List... | true |
IsModuleTopology.topologicalAddGroup | Mathlib.Topology.Algebra.Module.ModuleTopology | ∀ (R : Type u_1) [τR : TopologicalSpace R] [inst : Semiring R] (C : Type u_6) [inst_1 : AddCommGroup C]
[inst_2 : Module R C] [inst_3 : TopologicalSpace C] [IsModuleTopology R C], IsTopologicalAddGroup C | true |
AList.insertRec._proof_3 | Mathlib.Data.List.AList | ∀ {α : Type u_1} {β : α → Type u_2} (c : Sigma β) (l : List (Sigma β)) (h : (c :: l).NodupKeys),
c.fst ∉ { entries := l, nodupKeys := ⋯ }.entries.keys | false |
AddAction.IsQuasiPreprimitive.casesOn | Mathlib.GroupTheory.GroupAction.Primitive | {G : Type u_1} →
{X : Type u_2} →
[inst : AddGroup G] →
[inst_1 : AddAction G X] →
{motive : AddAction.IsQuasiPreprimitive G X → Sort u} →
(t : AddAction.IsQuasiPreprimitive G X) →
([toIsPretransitive : AddAction.IsPretransitive G X] →
(isPretransitive_of_normal... | false |
Finset.sum_induction_nonempty | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {s : Finset ι} {M : Type u_7} [inst : AddCommMonoid M] (f : ι → M) (p : M → Prop),
(∀ (a b : M), p a → p b → p (a + b)) → s.Nonempty → (∀ x ∈ s, p (f x)) → p (∑ x ∈ s, f x) | true |
ZFSet.powerset.match_5 | Mathlib.SetTheory.ZFC.Basic | ∀ (α : Type u_1) (A : α → PSet.{u_1}) (α_1 : Type u_1) (B : α_1 → PSet.{u_1}) (q : Set (PSet.mk α_1 B).Type)
(motive : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)} → Prop) (x : ↑{a | ∃ b ∈ q, (A a).Equiv (B b)}),
(∀ (val : (PSet.mk α A).Type) (b : (PSet.mk α_1 B).Type) (qb : b ∈ q) (ab : (A val).Equiv (B b)), motive ⟨val, ⋯⟩)... | false |
Lean.Parser.ParserAttributeHook.recOn | Lean.Parser.Extension | {motive : Lean.Parser.ParserAttributeHook → Sort u} →
(t : Lean.Parser.ParserAttributeHook) →
((postAdd : Lean.Name → Lean.Name → Bool → Lean.AttrM Unit) → motive { postAdd := postAdd }) → motive t | false |
Lean.Elab.CompletionInfo.dotId.sizeOf_spec | Lean.Elab.InfoTree.Types | ∀ (stx : Lean.Syntax) (id : Lean.Name) (lctx : Lean.LocalContext) (expectedType? : Option Lean.Expr),
sizeOf (Lean.Elab.CompletionInfo.dotId stx id lctx expectedType?) =
1 + sizeOf stx + sizeOf id + sizeOf lctx + sizeOf expectedType? | true |
Lean.PrettyPrinter.Formatter.charLitNoAntiquot.formatter | Lean.PrettyPrinter.Formatter | Lean.PrettyPrinter.Formatter | true |
TopologicalSpace.rec | Mathlib.Topology.Defs.Basic | {X : Type u} →
{motive : TopologicalSpace X → Sort u_1} →
((IsOpen : Set X → Prop) →
(isOpen_univ : IsOpen Set.univ) →
(isOpen_inter : ∀ (s t : Set X), IsOpen s → IsOpen t → IsOpen (s ∩ t)) →
(isOpen_sUnion : ∀ (s : Set (Set X)), (∀ t ∈ s, IsOpen t) → IsOpen (⋃₀ s)) →
m... | false |
Lean.Elab.Tactic.BVDecide.LRAT.trim.State._sizeOf_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | Lean.Elab.Tactic.BVDecide.LRAT.trim.State → ℕ | false |
NumberField.InfinitePlace.Completion.bijective_extensionEmbeddingOfIsReal | Mathlib.NumberTheory.NumberField.Completion.InfinitePlace | ∀ {K : Type u_1} [inst : Field K] {v : NumberField.InfinitePlace K} (hv : v.IsReal),
Function.Bijective ⇑(NumberField.InfinitePlace.Completion.extensionEmbeddingOfIsReal hv) | true |
Metric.IsCover.subset_iUnion_closedBall | Mathlib.Topology.MetricSpace.Cover | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {ε : NNReal} {s N : Set X},
Metric.IsCover ε s N → s ⊆ ⋃ y ∈ N, Metric.closedBall y ↑ε | true |
Lean.Compiler.LCNF.LCtx.eraseLetDecl | Lean.Compiler.LCNF.LCtx | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.LCtx → Lean.Compiler.LCNF.LetDecl pu → Lean.Compiler.LCNF.LCtx | true |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.introSubstEq.match_7 | Lean.Meta.Tactic.Subst | (motive : DoResultPR (Lean.Meta.FVarSubst × Lean.MVarId) (Lean.Meta.FVarSubst × Lean.MVarId) PUnit.{1} → Sort u_1) →
(r : DoResultPR (Lean.Meta.FVarSubst × Lean.MVarId) (Lean.Meta.FVarSubst × Lean.MVarId) PUnit.{1}) →
((a : Lean.Meta.FVarSubst × Lean.MVarId) → (u : PUnit.{1}) → motive (DoResultPR.pure a u)) →
... | false |
Nat.Linear.Poly.norm.go.eq_1 | Init.Data.Nat.Linear | ∀ (r : Nat.Linear.Poly), Nat.Linear.Poly.norm.go [] r = r | true |
FP.RMode.recOn | Mathlib.Data.FP.Basic | {motive : FP.RMode → Sort u} → (t : FP.RMode) → motive FP.RMode.NE → motive t | false |
Lean.Elab.Command.MacroExpandedSnapshot.isFatal._inherited_default | Lean.Elab.Command | Bool | false |
_private.Mathlib.NumberTheory.Bernoulli.0.bernoulli'_eq_bernoulli._simp_1_4 | Mathlib.NumberTheory.Bernoulli | ∀ {M : Type u_2} [inst : Monoid M] (a : M) (m n : ℕ), (a ^ m) ^ n = a ^ (m * n) | false |
BoxIntegral.integral_sub | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f g : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxI... | true |
_private.Mathlib.Data.List.Duplicate.0.List._aux_Mathlib_Data_List_Duplicate___unexpand_List_Duplicate_1 | Mathlib.Data.List.Duplicate | Lean.PrettyPrinter.Unexpander | false |
ContinuousLinearMap.flip_zero | Mathlib.Analysis.Normed.Operator.Bilinear | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {𝕜₃ : Type u_3} {E : Type u_4} {F : Type u_6} {G : Type u_8}
[inst : SeminormedAddCommGroup E] [inst_1 : SeminormedAddCommGroup F] [inst_2 : SeminormedAddCommGroup G]
[inst_3 : NontriviallyNormedField 𝕜] [inst_4 : NontriviallyNormedField 𝕜₂] [inst_5 : NontriviallyNormedField 𝕜... | true |
LinearMap.instDistribMulAction._proof_2 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_2} {S : Type u_5} {M : Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : Monoid S] [inst_7 : DistribMulAction S M₂]
[inst_8 : SMulCommCla... | false |
_private.Mathlib.CategoryTheory.Limits.Shapes.Biproducts.0.CategoryTheory.Limits.instHasBiproductSigmaFstSndOfBiproduct.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {ι : Type u_1} (f : ι → Type u_2) (motive : (i : ι) × f i → Prop) (x : (i : ι) × f i),
(∀ (j' : ι) (y : f j'), motive ⟨j', y⟩) → motive x | false |
CategoryTheory.Subgroupoid.mem_top_objs | Mathlib.CategoryTheory.Groupoid.Subgroupoid | ∀ {C : Type u} [inst : CategoryTheory.Groupoid C] (c : C), c ∈ ⊤.objs | true |
MeasurableMul | Mathlib.MeasureTheory.Group.Arithmetic | (M : Type u_2) → [MeasurableSpace M] → [Mul M] → Prop | true |
LinearMap.ext_on | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring R₂] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{s : Set M} {f g : M →ₛₗ[σ₁₂] M₂}, Submodule.span R s = ⊤ → Set.EqOn (⇑f) (⇑g) s → f = g | true |
_private.Mathlib.Logic.Equiv.Basic.0.Equiv.swap_eq_refl_iff._proof_1_1 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_1} [inst : DecidableEq α] {x y : α}, Equiv.swap x y = Equiv.refl α → (Equiv.refl α) x = (Equiv.refl α) y | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.memLp_stoppedValue._simp_1_1 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
Aesop.RappData.successProbability | Aesop.Tree.Data | {Goal MVarCluster : Type} → Aesop.RappData Goal MVarCluster → Aesop.Percent | true |
Holor.instAddMonoid | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddMonoid α] → AddMonoid (Holor α ds) | true |
_private.Mathlib.Analysis.FunctionalSpaces.SobolevInequality.0.MeasureTheory.eLpNorm_le_eLpNorm_fderiv_of_eq_inner._simp_1_14 | Mathlib.Analysis.FunctionalSpaces.SobolevInequality | ∀ (x : ENNReal) (y z : ℝ), (x ^ y) ^ z = x ^ (y * z) | false |
FDerivMeasurableAux.B | Mathlib.Analysis.Calculus.FDeriv.Measurable | {𝕜 : Type u_1} →
[inst : NontriviallyNormedField 𝕜] →
{E : Type u_2} →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
{F : Type u_3} →
[inst_3 : NormedAddCommGroup F] → [inst_4 : NormedSpace 𝕜 F] → (E → F) → Set (E →L[𝕜] F) → ℝ → ℝ → ℝ → Set E | true |
OmegaCompletePartialOrder.Chain.map_comp | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(c : OmegaCompletePartialOrder.Chain α) {f : α →o β} (g : β →o γ), (c.map f).map g = c.map (g.comp f) | true |
Std.DTreeMap.Raw.minKey!_alter_eq_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] [inst_1 : Inhabited α],
t.WF →
∀ {k : α} {f : Option (β k) → Option (β k)},
(t.alter k f).isEmpty = false →
((t.alter k f).minKey! = k ↔ (f (t.get? k)).isSome = t... | true |
one_lt_iff_ne_one | Mathlib.Algebra.Order.Monoid.Canonical.Defs | ∀ {α : Type u} [inst : MulOneClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedMul α] {a : α}, 1 < a ↔ a ≠ 1 | true |
CauSeq.le_total | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α] (f g : CauSeq α abs),
f ≤ g ∨ g ≤ f | true |
MeasureTheory.tendstoInMeasure_of_tendsto_eLpNorm_top | Mathlib.MeasureTheory.Function.ConvergenceInMeasure | ∀ {α : Type u_1} {ι : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {E : Type u_5}
[inst : SeminormedAddCommGroup E] {f : ι → α → E} {g : α → E} {l : Filter ι},
Filter.Tendsto (fun n => MeasureTheory.eLpNorm (f n - g) ⊤ μ) l (nhds 0) → MeasureTheory.TendstoInMeasure μ f l g | true |
Lean.mkCIdentFromRef | Init.Meta.Defs | {m : Type → Type} → [Monad m] → [Lean.MonadRef m] → Lean.Name → optParam Bool false → m Lean.Syntax | true |
MeasureTheory.Measure.completion._proof_1 | Mathlib.MeasureTheory.Measure.NullMeasurable | ∀ {α : Type u_1} {x : MeasurableSpace α} (μ : MeasureTheory.Measure α), μ.trim ≤ μ.toOuterMeasure | false |
HomotopicalAlgebra.PathObject.recOn | Mathlib.AlgebraicTopology.ModelCategory.PathObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] →
{A : C} →
{motive : HomotopicalAlgebra.PathObject A → Sort u_1} →
(t : HomotopicalAlgebra.PathObject A) →
((toPrepathObject : HomotopicalAlgebra.PrepathObje... | false |
Subsemiring.center.smulCommClass_right | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R' : Type u_1} [inst : Semiring R'], SMulCommClass R' (↥(Subsemiring.center R')) R' | true |
IsCompact.exists_bound_of_continuousOn' | Mathlib.Analysis.Normed.Group.Bounded | ∀ {α : Type u_1} {E : Type u_2} [inst : SeminormedGroup E] [inst_1 : TopologicalSpace α] {s : Set α},
IsCompact s → ∀ {f : α → E}, ContinuousOn f s → ∃ C, ∀ x ∈ s, ‖f x‖ ≤ C | true |
NonemptyInterval.instPartialOrderLex | Mathlib.Order.Interval.Lex | {α : Type u_1} → [inst : PartialOrder α] → PartialOrder (Lex (NonemptyInterval α)) | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.