name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Lean.Elab.Tactic.Grind.Have.0.Lean.Elab.Tactic.Grind.elabTerm | Lean.Elab.Tactic.Grind.Have | Lean.Syntax → Option Lean.Expr → optParam Bool false → Lean.Elab.Tactic.Grind.GrindTacticM Lean.Expr | true |
Measurable.const_sub | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {G : Type u_2} {α : Type u_3} [inst : MeasurableSpace G] [inst_1 : Sub G] {m : MeasurableSpace α} {f : α → G}
[MeasurableSub G], Measurable f → ∀ (c : G), Measurable fun x => c - f x | true |
CategoryTheory.LocalizerMorphism.IsLocalizedEquivalence.isEquivalence | Mathlib.CategoryTheory.Localization.LocalizerMorphism | ∀ {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₂} {Φ : CategoryTheory.LocalizerMorphism W₁ W₂}
[self : Φ.IsLocalizedEquivalence], (Φ.localizedFunctor W₁.Q W... | true |
Lean.Parser.Attr.tactic_alt._regBuiltin.Lean.Parser.Attr.tactic_alt.docString_3 | Lean.Parser.Attr | IO Unit | false |
AList.instInhabited | Mathlib.Data.List.AList | {α : Type u} → {β : α → Type v} → Inhabited (AList β) | true |
Filter.instSub | Mathlib.Order.Filter.Pointwise | {α : Type u_2} → [Sub α] → Sub (Filter α) | true |
Lean.Server.Logging.LogConfig.mk._flat_ctor | Lean.Server.Logging | Bool → System.FilePath → Option (Std.HashSet String) → Option (Std.HashSet String) → Lean.Server.Logging.LogConfig | false |
Fin.reverseInduction._proof_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {motive : Fin (n + 1) → Sort u_1} (i : Fin (n + 1)) (j : ℕ) (h : j < n + 1), ↑i = j → motive ⟨j, h⟩ = motive i | false |
FormalMultilinearSeries.order_eq_zero_iff | Mathlib.Analysis.Calculus.FormalMultilinearSeries | ∀ {𝕜 : Type u} {E : Type v} {F : Type w} [inst : Semiring 𝕜] [inst_1 : AddCommMonoid E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] [inst_5 : ContinuousConstSMul 𝕜 E] [inst_6 : AddCommMonoid F]
[inst_7 : Module 𝕜 F] [inst_8 : TopologicalSpace F] [inst_9 : ContinuousAdd F] [in... | true |
jacobiSum_one_nontrivial | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {F : Type u_1} {R : Type u_2} [inst : Field F] [inst_1 : Fintype F] [inst_2 : CommRing R] [IsDomain R]
{χ : MulChar F R}, χ ≠ 1 → jacobiSum 1 χ = -1 | true |
LieModuleEquiv.ext | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u} {L : Type v} {M : Type w} {N : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : AddCommGroup N] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : LieRingModule L M] [inst_7 : LieRingModule L N] (e₁ e₂ : M ≃ₗ⁅R,L⁆ N), (∀ (m : M), e₁ m = e₂ m) → e₁ = e₂ | true |
Cardinal.liftInitialSeg._proof_2 | Mathlib.SetTheory.Cardinal.Order | ∀ (a : Cardinal.{u_1}),
∀ b < (OrderEmbedding.ofMapLEIff Cardinal.lift.{u_2, u_1} Cardinal.liftInitialSeg._proof_1).ltEmbedding a,
b ∈ Set.range ⇑(OrderEmbedding.ofMapLEIff Cardinal.lift.{u_2, u_1} Cardinal.liftInitialSeg._proof_1).ltEmbedding | false |
CochainComplex.homotopyOp | Mathlib.Algebra.Homology.CochainComplexOpposite | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{K L : CochainComplex C ℤ} →
{f g : K ⟶ L} →
Homotopy f g →
Homotopy ((CochainComplex.opEquivalence C).functor.map f.op)
((CochainComplex.opEquivalence C).fu... | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insert_le_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
IncidenceAlgebra.instNonUnitalNonAssocSemiring._proof_4 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α]
[inst_2 : NonUnitalNonAssocSemiring 𝕜] (f : IncidenceAlgebra 𝕜 α), f * 0 = 0 | false |
LinearEquiv.skewSwap_symm_apply | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u} {M : Type v} {N : Type u_3} [inst : Semiring R] [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : Module R M] [inst_4 : Module R N] (x : N × M), (LinearEquiv.skewSwap R M N).symm x = (x.2, -x.1) | true |
String.splitAux._unsafe_rec | Init.Data.String.Legacy | String → (Char → Bool) → String.Pos.Raw → String.Pos.Raw → List String → List String | false |
Lean.RBNode.map._sunfold | Lean.Data.RBMap | {α : Type u} → {β γ : α → Type v} → ((a : α) → β a → γ a) → Lean.RBNode α β → Lean.RBNode α γ | false |
WeierstrassCurve.IsCharThreeNF.of_j_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.NormalForms | ∀ {R : Type u_1} [inst : CommRing R] {W : WeierstrassCurve R} [W.IsShortNF], W.IsCharThreeNF | true |
RingEquiv.symm_apply_eq | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : Mul R] [inst_1 : Mul S] [inst_2 : Add R] [inst_3 : Add S] (e : R ≃+* S) {x : S}
{y : R}, e.symm x = y ↔ x = e y | true |
MeasureTheory.ae_eq_set | Mathlib.MeasureTheory.OuterMeasure.AE | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [inst_1 : MeasureTheory.OuterMeasureClass F α]
{μ : F} {s t : Set α}, s =ᵐ[μ] t ↔ μ (s \ t) = 0 ∧ μ (t \ s) = 0 | true |
CategoryTheory.CosimplicialObject.instHasColimits | Mathlib.AlgebraicTopology.SimplicialObject.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasColimits C],
CategoryTheory.Limits.HasColimits (CategoryTheory.CosimplicialObject C) | true |
Std.Time.FormatType._unsafe_rec | Std.Time.Format.Basic | Type → Std.Time.FormatString → Type | false |
RingHomIsometric.mk._flat_ctor | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R₁ : Type u_5} {R₂ : Type u_6} [inst : Semiring R₁] [inst_1 : Semiring R₂] [inst_2 : Norm R₁] [inst_3 : Norm R₂]
{σ : R₁ →+* R₂}, (∀ {x : R₁}, ‖σ x‖ = ‖x‖) → RingHomIsometric σ | false |
iUnion_Ici_eq_Ici_iInf | Mathlib.Order.Interval.Set.Disjoint | ∀ {ι : Sort u} {R : Type u_1} [inst : CompleteLinearOrder R] {f : ι → R},
⨅ i, f i ∈ Set.range f → ⋃ i, Set.Ici (f i) = Set.Ici (⨅ i, f i) | true |
Path.Homotopy.refl | Mathlib.Topology.Homotopy.Path | {X : Type u} → [inst : TopologicalSpace X] → {x₀ x₁ : X} → (p : Path x₀ x₁) → p.Homotopy p | true |
CategoryTheory.ShortComplex.HomologyMapData.noConfusion | Mathlib.Algebra.Homology.ShortComplex.Homology | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} →
{S₁ S₂ : CategoryTheory.ShortComplex C} →
{φ : S₁ ⟶ S₂} →
{h₁ : S₁.HomologyData} →
{h₂ : S₂.HomologyData} →
{t : Categ... | false |
ProbabilityTheory.Kernel.instIsSFiniteKernelBorelMarkovFromReal | Mathlib.Probability.Kernel.Disintegration.StandardBorel | ∀ {α : Type u_1} {Ω : Type u_4} {mα : MeasurableSpace α} {mΩ : MeasurableSpace Ω} [inst : StandardBorelSpace Ω]
[inst_1 : Nonempty Ω] (η : ProbabilityTheory.Kernel α ℝ) [ProbabilityTheory.IsSFiniteKernel η],
ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.borelMarkovFromReal Ω η) | true |
_private.Mathlib.Topology.Order.0.closure_induced._simp_1_4 | Mathlib.Topology.Order | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | false |
Std.TreeMap.size_alter_eq_self_of_mem | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
{f : Option β → Option β}, k ∈ t → (f t[k]?).isSome = true → (t.alter k f).size = t.size | true |
ENNReal.tendsto_coe | Mathlib.Topology.Algebra.Ring.Real | ∀ {α : Type u} {f : Filter α} {m : α → NNReal} {a : NNReal},
Filter.Tendsto (fun a => ↑(m a)) f (nhds ↑a) ↔ Filter.Tendsto m f (nhds a) | true |
TopCat.prodIsoProd_hom_snd_assoc | Mathlib.Topology.Category.TopCat.Limits.Products | ∀ (X Y : TopCat) {Z : TopCat} (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (X.prodIsoProd Y).hom (CategoryTheory.CategoryStruct.comp TopCat.prodSnd h) =
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd h | true |
Std.Internal.List.getValueCast?_filter_not_contains_map_fst_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getValueCast? k (List.filter (fun p => !(List.map Sigma.fst l₂).contains p.fst) l₁) = none | true |
LieAlgebra.Extension.recOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing N] →
[inst_2 : LieAlgebra R N] →
[inst_3 : LieRing M] →
[inst_4 : LieAlgebra R M] →
{motive : LieAlgebra.Extension R N M → Sort u} →
(t : L... | false |
CategoryTheory.ShortComplex.RightHomologyData.op_i | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData), h.op.i = h.p.op | true |
_private.Mathlib.RingTheory.Invariant.Basic.0.fixed_of_fixed1 | Mathlib.RingTheory.Invariant.Basic | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] (G : Type u_3)
[inst_3 : Group G] [Finite G] [inst_5 : MulSemiringAction G B] [inst_6 : SMulCommClass G A B] (P : Ideal A)
(Q : Ideal B) [Q.IsPrime] [inst_8 : Q.LiesOver P] (K : Type u_4) (L : Type u_5) [inst_9 : Field ... | true |
Matrix.compAlgEquiv | Mathlib.Data.Matrix.Composition | (I : Type u_1) →
(J : Type u_2) →
(R : Type u_5) →
(K : Type u_7) →
[inst : CommSemiring K] →
[inst_1 : Semiring R] →
[inst_2 : Fintype I] →
[inst_3 : Fintype J] →
[inst_4 : Algebra K R] →
[inst_5 : DecidableEq I] →
... | true |
Lean.Widget.HighlightedMsgEmbed.goal.inj | Lean.Server.FileWorker.WidgetRequests | ∀ {a a_1 : Lean.Widget.InteractiveGoal},
Lean.Widget.HighlightedMsgEmbed.goal a = Lean.Widget.HighlightedMsgEmbed.goal a_1 → a = a_1 | true |
Lean.MonadCacheT.instMonad._aux_7 | Lean.Util.MonadCache | {ω α β : Type} →
{m : Type → Type} →
[inst : STWorld ω m] →
[inst_1 : BEq α] →
[inst_2 : Hashable α] →
[Monad m] →
{α_1 β_1 : Type} →
Lean.MonadCacheT α β m (α_1 → β_1) → (Unit → Lean.MonadCacheT α β m α_1) → Lean.MonadCacheT α β m β_1 | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.normLitValue.match_17 | Lean.Meta.LitValues | (motive : Option UInt64 → Sort u_1) →
(__do_lift : Option UInt64) → ((n : UInt64) → motive (some n)) → ((x : Option UInt64) → motive x) → motive __do_lift | false |
Vector.lt_of_le_of_lt | Init.Data.Vector.Lex | ∀ {α : Type u_1} {n : ℕ} [inst : LT α] [inst_1 : LE α] [Std.LawfulOrderLT α] [Std.IsLinearOrder α]
{xs ys zs : Vector α n}, xs ≤ ys → ys < zs → xs < zs | true |
CliffordAlgebra.equivExterior._proof_4 | Mathlib.LinearAlgebra.CliffordAlgebra.Contraction | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SMulCommClass R R (M →ₗ[R] R) | false |
Polynomial.map_neg | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Ring R] {p : Polynomial R} {S : Type u_1} [inst_1 : Ring S] (f : R →+* S),
Polynomial.map f (-p) = -Polynomial.map f p | true |
Int.nonpos_of_mul_nonpos_right | Init.Data.Int.Order | ∀ {a b : ℤ}, a * b ≤ 0 → 0 < a → b ≤ 0 | true |
_private.Mathlib.Probability.Distributions.Uniform.0.PMF.toOuterMeasure_uniformOfFinset_apply._simp_1_2 | Mathlib.Probability.Distributions.Uniform | ∀ {α : Sort u_1} (P Q : Prop) [inst : Decidable P] (a b : α) [inst_1 : Decidable Q],
(if P then if Q then a else b else b) = if P ∧ Q then a else b | false |
Std.DTreeMap.Internal.Impl.size_alter_eq_self_of_mem | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k : α} {f : Option (β k) → Option (β k)},
k ∈ t → (f (t.get? k)).isSome = true → (Std.DTreeMap.Internal.Impl.alter k f t ⋯).impl.size = t.size | true |
SchwartzMap.toTemperedDistributionCLM._proof_8 | Mathlib.Analysis.Distribution.TemperedDistribution | ∀ (E : Type u_1) (F : Type u_2) [inst : NormedAddCommGroup E] [inst_1 : NormedAddCommGroup F] [inst_2 : NormedSpace ℝ E]
[inst_3 : NormedSpace ℂ F], ContinuousAdd (SchwartzMap E F) | false |
Std.ExtDTreeMap.Const.get?_eq_some_getD | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{a : α} {fallback : β}, a ∈ t → Std.ExtDTreeMap.Const.get? t a = some (Std.ExtDTreeMap.Const.getD t a fallback) | true |
Std.Packages.LinearOrderOfOrdArgs.mk.sizeOf_spec | Init.Data.Order.PackageFactories | ∀ {α : Type u} [inst : SizeOf α] (toLinearPreorderOfOrdArgs : Std.Packages.LinearPreorderOfOrdArgs α)
(eq_of_compare :
autoParam
(let this := toLinearPreorderOfOrdArgs.ord;
let this_1 := toLinearPreorderOfOrdArgs.le;
∀ (a b : α), compare a b = Ordering.eq → a = b)
Std.Packages.LinearOrderO... | true |
Set.indicator_eq_indicator | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_3} [inst : Zero M] {s : Set α} {f : α → M} {a : α} {t : Set β} {g : β → M}
{b : β}, (a ∈ s ↔ b ∈ t) → f a = g b → s.indicator f a = t.indicator g b | true |
_private.Mathlib.FieldTheory.Extension.0.IntermediateField.Lifts.nonempty_algHom_of_exist_lifts_finset._simp_1_14 | Mathlib.FieldTheory.Extension | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | false |
instIsStronglyCoatomicElemOfOrdConnected | Mathlib.Order.Atoms | ∀ {α : Type u_4} [inst : Preorder α] [IsStronglyCoatomic α] {s : Set α} [h : s.OrdConnected], IsStronglyCoatomic ↑s | true |
_private.Std.Data.Iterators.Lemmas.Producers.Monadic.Empty.0.Std.IterM.forIn'_eq_match_step.match_1.eq_1 | Std.Data.Iterators.Lemmas.Producers.Monadic.Empty | ∀ {γ : Type u_1} (motive : ForInStep γ → Sort u_2) (c : γ) (h_1 : (c : γ) → motive (ForInStep.yield c))
(h_2 : (c : γ) → motive (ForInStep.done c)),
(match ForInStep.yield c with
| ForInStep.yield c => h_1 c
| ForInStep.done c => h_2 c) =
h_1 c | true |
_private.Mathlib.Topology.MetricSpace.CoveringNumbers.0.Metric.exists_set_encard_eq_coveringNumber._simp_1_8 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
BitVec.toNat_sub | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} (x y : BitVec n), (x - y).toNat = (2 ^ n - y.toNat + x.toNat) % 2 ^ n | true |
Lean.Lsp.PlainTermGoal.noConfusionType | Lean.Data.Lsp.Extra | Sort u → Lean.Lsp.PlainTermGoal → Lean.Lsp.PlainTermGoal → Sort u | false |
Std.Internal.IO.Async.Selector.mk.sizeOf_spec | Std.Internal.Async.Select | ∀ {α : Type} [inst : SizeOf α] (tryFn : Std.Internal.IO.Async.Async (Option α))
(registerFn : Std.Internal.IO.Async.Waiter α → Std.Internal.IO.Async.Async Unit)
(unregisterFn : Std.Internal.IO.Async.Async Unit),
sizeOf { tryFn := tryFn, registerFn := registerFn, unregisterFn := unregisterFn } = 1 | true |
Int64.toFin_toBitVec | Init.Data.SInt.Lemmas | ∀ (x : Int64), x.toBitVec.toFin = x.toUInt64.toFin | true |
LocallyConstant.instCommMonoid._proof_1 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : CommMonoid Y], ⇑1 = ⇑1 | false |
CategoryTheory.Bicategory.associator_inv_naturality_left_assoc | Mathlib.CategoryTheory.Bicategory.Basic | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f f' : a ⟶ b} (η : f ⟶ f') (g : b ⟶ c) (h : c ⟶ d)
{Z : a ⟶ d} (h_1 : CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f' g) h ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Bicategory.whiskerRight η (CategoryTheory.C... | true |
PreTilt.instCommRing._proof_7 | Mathlib.RingTheory.Perfection | ∀ (O : Type u_1) [inst : CommRing O] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p] (a : PreTilt O p),
a + 0 = a | false |
CategoryTheory.Groupoid.toCategory | Mathlib.CategoryTheory.Groupoid | {obj : Type u} → [self : CategoryTheory.Groupoid obj] → CategoryTheory.Category.{v, u} obj | true |
CategoryTheory.Mon.instPreservesLimitsOfShapeForgetOfHasLimitsOfShape | Mathlib.CategoryTheory.Monoidal.Internal.Limits | ∀ {J : Type w} [inst : CategoryTheory.Category.{v_1, w} J] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.PreservesLimitsOfShape J (CategoryTheory.Mon.forget C) | true |
WittVector.RecursionMain.succNthDefiningPoly.congr_simp | Mathlib.RingTheory.WittVector.FrobeniusFractionField | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] {k : Type u_1} [inst : CommRing k] [inst_1 : CharP k p] (n : ℕ)
(a₁ a₁_1 : WittVector p k),
a₁ = a₁_1 →
∀ (a₂ a₂_1 : WittVector p k),
a₂ = a₂_1 →
∀ (bs bs_1 : Fin (n + 1) → k),
bs = bs_1 →
WittVector.RecursionMain.succNthDefiningPoly p n a₁... | true |
RingTheory.LinearMap.«_aux_Mathlib_Algebra_Algebra_Bilinear___macroRules_RingTheory_LinearMap_termμ[_]_1» | Mathlib.Algebra.Algebra.Bilinear | Lean.Macro | false |
_private.Lean.Meta.Tactic.Apply.0.Lean.Meta.isDefEqApply | Lean.Meta.Tactic.Apply | Bool → Lean.Expr → Lean.Expr → Lean.MetaM Bool | true |
addConj_add | Mathlib.Algebra.Group.Conj | ∀ {α : Type u} [inst : AddGroup α] {a b c : α}, b + a + -b + (b + c + -b) = b + (a + c) + -b | true |
CategoryTheory.ComposableArrows.isoMk₂._proof_1 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {f g : CategoryTheory.ComposableArrows C 2}
(app₀ : f.obj' 0 _proof_237✝ ≅ g.obj' 0 _proof_237✝¹) (app₁ : f.obj' 1 _proof_238✝ ≅ g.obj' 1 _proof_238✝¹),
CategoryTheory.CategoryStruct.comp (f.map' 0 1 CategoryTheory.ComposableArrows.homMk₁._proof_4 _proo... | false |
Lean.Core.InstantiateLevelCache | Lean.CoreM | Type | true |
Lean.Elab.Term.ElabElim.Context.mk._flat_ctor | Lean.Elab.App | Lean.Elab.Term.ElabElimInfo → Lean.Expr → Lean.Elab.Term.ElabElim.Context | false |
FractionalIdeal.semifield._proof_9 | Mathlib.RingTheory.DedekindDomain.Ideal.Basic | ∀ {A : Type u_2} {K : Type u_1} [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] [inst_4 : IsDedekindDomain A], 0⁻¹ = 0 | false |
Hyperreal.coe_max | Mathlib.Analysis.Real.Hyperreal | ∀ (x y : ℝ), ↑(max x y) = max ↑x ↑y | true |
Int32.toUInt32_xor | Init.Data.SInt.Bitwise | ∀ (a b : Int32), (a ^^^ b).toUInt32 = a.toUInt32 ^^^ b.toUInt32 | true |
List.head_attachWith._proof_1 | Init.Data.List.Attach | ∀ {α : Type u_1} {P : α → Prop} {xs : List α} {H : ∀ a ∈ xs, P a}, xs.attachWith P H ≠ [] → xs ≠ [] | false |
OrderMonoidIso.self_comp_symm | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β]
(e : α ≃*o β), ⇑e ∘ ⇑e.symm = id | true |
NNReal.coe_iSup._simp_1 | Mathlib.Data.NNReal.Defs | ∀ {ι : Sort u_2} (s : ι → NNReal), ⨆ i, ↑(s i) = ↑(⨆ i, s i) | false |
nonempty_prop | Init.PropLemmas | ∀ {p : Prop}, Nonempty p ↔ p | true |
Std.Time.Minute.Ordinal | Std.Time.Time.Unit.Minute | Type | true |
UniformEquiv.setCongr._proof_2 | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u_1} [inst : UniformSpace α] {s t : Set α} (h : s = t), UniformContinuous fun x => ⟨↑x, ⋯⟩ | false |
Matroid.Indep.cardinalMk_le_isBasis' | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α : Type u} {M : Matroid α} {I J X : Set α} [M.InvariantCardinalRank],
M.Indep I → M.IsBasis' J X → I ⊆ X → Cardinal.mk ↑I ≤ Cardinal.mk ↑J | true |
Lean.Meta.Simp.withPreservedCache | Lean.Meta.Tactic.Simp.Types | {α : Type} → Lean.Meta.SimpM α → Lean.Meta.SimpM α | true |
LinearMap.BilinForm.linMulLin_compRight | Mathlib.LinearAlgebra.BilinearForm.Hom | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f g : M →ₗ[R] R} (r : M →ₗ[R] M),
(LinearMap.BilinForm.linMulLin f g).compRight r = LinearMap.BilinForm.linMulLin f (g ∘ₗ r) | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey?_insertMany_list_of_contains_eq_false._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
SkewMonoidAlgebra.instAddGroupWithOne._proof_4 | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddGroupWithOne k] [inst_1 : One G] (n : ℕ), (Int.negSucc n).castDef = -↑(n + 1) | false |
_private.Mathlib.Topology.Separation.CompletelyRegular.0.completelyRegularSpace_iInf._simp_1_1 | Mathlib.Topology.Separation.CompletelyRegular | ∀ {α : Type u} {ι : Type u_2} {s : ι → Filter α} {U : Set α},
(U ∈ ⨅ i, s i) = ∃ I, I.Finite ∧ ∃ V, (∀ (i : ↑I), V i ∈ s ↑i) ∧ U = ⋂ i, V i | false |
Std.DHashMap.Internal.Raw₀.Const.isEmpty_toArray | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} (m : Std.DHashMap.Internal.Raw₀ α fun x => β)
[EquivBEq α] [LawfulHashable α], (↑m).WF → (Std.DHashMap.Raw.Const.toArray ↑m).isEmpty = (↑m).isEmpty | true |
MultilinearMap.pi_ext_iff | Mathlib.LinearAlgebra.Multilinear.Pi | ∀ {ι : Type uι} {κ : ι → Type uκ} {R : Type uR} {M : (i : ι) → κ i → Type uM} {N : Type uN} [inst : Semiring R]
[inst_1 : (i : ι) → (k : κ i) → AddCommMonoid (M i k)] [inst_2 : AddCommMonoid N]
[inst_3 : (i : ι) → (k : κ i) → Module R (M i k)] [inst_4 : Module R N] [Finite ι] [∀ (i : ι), Finite (κ i)]
[inst_7 : (... | true |
CommRingCat.limitCommRing | Mathlib.Algebra.Category.Ring.Limits | {J : Type v} →
[inst : CategoryTheory.Category.{w, v} J] →
(F : CategoryTheory.Functor J CommRingCat) →
[inst_1 : Small.{u, max u v} ↑(F.comp (CategoryTheory.forget CommRingCat)).sections] →
CommRing (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommRingCat))).pt | true |
not_maximal_iff_exists_gt | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P : α → Prop} {x : α} [inst : Preorder α], P x → (¬Maximal P x ↔ ∃ y, x < y ∧ P y) | true |
Lean.Meta.Grind.Arith.Linear.UnsatProof.lt | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.IneqCnstr → Lean.Meta.Grind.Arith.Linear.UnsatProof | true |
_private.Mathlib.SetTheory.Ordinal.FixedPointApproximants.0.OrdinalApprox.lfpApprox_monotone._simp_1_5 | Mathlib.SetTheory.Ordinal.FixedPointApproximants | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | false |
Lean.Server.Completion.EligibleDecl.tags | Lean.Server.Completion.EligibleHeaderDecls | Lean.Server.Completion.EligibleDecl → Lean.MetaM (Array Lean.Lsp.CompletionItemTag) | true |
AlgebraicGeometry.Scheme.PartialMap.mk.sizeOf_spec | Mathlib.AlgebraicGeometry.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (domain : X.Opens) (dense_domain : Dense ↑domain) (hom : ↑domain ⟶ Y),
sizeOf { domain := domain, dense_domain := dense_domain, hom := hom } = 1 + sizeOf domain + sizeOf hom | true |
Lean.Lsp.PublishDiagnosticsParams.recOn | Lean.Data.Lsp.Diagnostics | {motive : Lean.Lsp.PublishDiagnosticsParams → Sort u} →
(t : Lean.Lsp.PublishDiagnosticsParams) →
((uri : Lean.Lsp.DocumentUri) →
(version? : Option ℤ) →
(diagnostics : Array Lean.Lsp.Diagnostic) →
motive { uri := uri, version? := version?, diagnostics := diagnostics }) →
motiv... | false |
String.Slice.SplitIterator.noConfusionType | Init.Data.String.Slice | Sort u →
{σ : String.Slice → Type} →
{ρ : Type} →
{pat : ρ} →
{s : String.Slice} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
String.Slice.SplitIterator pat s →
{σ' : String.Slice → Type} →
{ρ' : Type} →
{pat' : ρ'} →... | false |
SimpleGraph.isVertexCover_bot | Mathlib.Combinatorics.SimpleGraph.VertexCover | ∀ {V : Type u_1} (c : Set V), ⊥.IsVertexCover c | true |
RelEmbedding.ctorIdx | Mathlib.Order.RelIso.Basic | {α : Type u_5} → {β : Type u_6} → {r : α → α → Prop} → {s : β → β → Prop} → r ↪r s → ℕ | false |
Ideal.pow_le_self | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R] {I : Ideal R} {n : ℕ}, n ≠ 0 → I ^ n ≤ I | true |
Lean.PersistentHashMap.Entry.null.elim | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{σ : Type w} →
{motive : Lean.PersistentHashMap.Entry α β σ → Sort u_1} →
(t : Lean.PersistentHashMap.Entry α β σ) → t.ctorIdx = 2 → motive Lean.PersistentHashMap.Entry.null → motive t | false |
Std.Rxo.IsAlwaysFinite | Init.Data.Range.Polymorphic.PRange | (α : Type u) → [Std.PRange.UpwardEnumerable α] → [LT α] → Prop | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.