name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Int.fract_pos | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] {a : R} [IsStrictOrderedRing R],
0 < Int.fract a ↔ a ≠ ↑⌊a⌋ | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastVar._proof_2 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Var | ∀ (w curr : ℕ), curr < w → curr + 1 ≤ w | false |
Multiset.one_le_prod | Mathlib.Algebra.Order.BigOperators.GroupWithZero.Multiset | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [inst_1 : PartialOrder R] [ZeroLEOneClass R] [PosMulMono R]
{s : Multiset R}, (∀ a ∈ s, 1 ≤ a) → 1 ≤ s.prod | true |
Std.Time.Month.instDecidableLtOrdinal._aux_1 | Std.Time.Date.Unit.Month | {x y : Std.Time.Month.Ordinal} → Decidable (x < y) | false |
Bornology.isBounded_image_subtype_val | Mathlib.Topology.Bornology.Constructions | ∀ {α : Type u_1} [inst : Bornology α] {p : α → Prop} {s : Set { x // p x }},
Bornology.IsBounded (Subtype.val '' s) ↔ Bornology.IsBounded s | true |
LatticeCon.mk'._proof_2 | Mathlib.Order.Lattice.Congruence | ∀ {α : Type u_1} [inst : Lattice α] (r : α → α → Prop),
(∀ ⦃x y : α⦄, r x y ↔ r (x ⊓ y) (x ⊔ y)) →
(∀ ⦃x y z : α⦄, x ≤ y → y ≤ z → r x y → r y z → r x z) →
(∀ ⦃x y t : α⦄, x ≤ y → r x y → r (x ⊓ t) (y ⊓ t) ∧ r (x ⊔ t) (y ⊔ t)) →
∀ {w x y z : α}, r w x → r y z → r (w ⊓ y) (x ⊓ z) | false |
MulActionHom.instSemiring | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_2} →
{N : Type u_3} →
{X : Type u_4} →
{Y : Type u_5} →
{σ : M → N} →
[inst : SMul M X] →
[inst_1 : Monoid N] → [inst_2 : Semiring Y] → [inst_3 : MulSemiringAction N Y] → Semiring (X →ₑ[σ] Y) | true |
ContinuousMap.instNonUnitalCommRingOfIsTopologicalRing._proof_2 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : NonUnitalCommRing β] [IsTopologicalRing β], ContinuousMul β | false |
Sublattice.instCompleteLattice._proof_5 | Mathlib.Order.Sublattice | ∀ {α : Type u_1} [inst : Lattice α] (s : Set (Sublattice α)), IsLUB s (sSup s) | false |
LinearMap.BilinForm.dualSubmoduleToDual._proof_5 | Mathlib.LinearAlgebra.BilinearForm.DualLattice | ∀ {R : Type u_2} {S : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : Field S] [inst_2 : AddCommGroup M]
[inst_3 : Algebra R S] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M]
(B : LinearMap.BilinForm S M) [inst_7 : IsDomain R] [inst_8 : Module.IsTorsionFree R S] (N : Submodule R M... | false |
TypeVec.dropFun_comp | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α₀ : TypeVec.{u_1} (n + 1)} {α₁ : TypeVec.{u_2} (n + 1)} {α₂ : TypeVec.{u_3} (n + 1)} (f₀ : α₀.Arrow α₁)
(f₁ : α₁.Arrow α₂), TypeVec.dropFun (TypeVec.comp f₁ f₀) = TypeVec.comp (TypeVec.dropFun f₁) (TypeVec.dropFun f₀) | true |
Prod.mk | Init.Prelude | {α : Type u} → {β : Type v} → α → β → α × β | true |
SimplexCategory.mkOfSucc_δ_lt | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} {i : Fin n} {j : Fin (n + 2)},
i.succ.castSucc < j →
CategoryTheory.CategoryStruct.comp (SimplexCategory.mkOfSucc i) (SimplexCategory.δ j) =
SimplexCategory.mkOfSucc i.castSucc | true |
_private.Init.Data.Iterators.Lemmas.Combinators.ULift.0.Std.IterM.step_uLift.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.ULift | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yi... | true |
Metric.Snowflaking.toEquiv_homeomorph | Mathlib.Topology.MetricSpace.Snowflaking | ∀ {X : Type u_1} {α : ℝ} {hα₀ : 0 < α} {hα₁ : α ≤ 1} [inst : TopologicalSpace X],
Metric.Snowflaking.homeomorph.toEquiv = Metric.Snowflaking.ofSnowflaking | true |
Complex.meromorphicNFOn_canonicalFactor | Mathlib.Analysis.Complex.CanonicalDecomposition | ∀ {R : ℝ} {w : ℂ}, w ∈ Metric.ball 0 R → MeromorphicNFOn (Complex.canonicalFactor R w) Set.univ | true |
DividedPowers.isSubDPIdeal_map | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} {B : Type u_2} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} [inst_1 : CommSemiring B]
{J : Ideal B} {hJ : DividedPowers J} {f : A →+* B}, hI.IsDPMorphism hJ f → hJ.IsSubDPIdeal (Ideal.map f I) | true |
Lean.Lsp.SymbolKind.typeParameter | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SymbolKind | true |
Lean.Compiler.LCNF.Arg.inferType | Lean.Compiler.LCNF.InferType | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Arg pu → Lean.Compiler.LCNF.CompilerM Lean.Expr | true |
CategoryTheory.instIsSplitMonoComp | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} {f : X ⟶ Y} {g : Y ⟶ Z}
[hf : CategoryTheory.IsSplitMono f] [hg : CategoryTheory.IsSplitMono g],
CategoryTheory.IsSplitMono (CategoryTheory.CategoryStruct.comp f g) | true |
quadraticChar | Mathlib.NumberTheory.LegendreSymbol.QuadraticChar.Basic | (F : Type u_1) → [inst : Field F] → [Fintype F] → [DecidableEq F] → MulChar F ℤ | true |
CategoryTheory.Limits.coprod.braiding_hom | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasBinaryCoproducts C]
(P Q : C),
(CategoryTheory.Limits.coprod.braiding P Q).hom =
CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.Limits.coprod.inl | true |
FaithfulVAdd.mk._flat_ctor | Mathlib.Algebra.Group.Action.Faithful | ∀ {G : Type u_4} {P : Type u_5} [inst : VAdd G P],
(∀ {g₁ g₂ : G}, (∀ (p : P), g₁ +ᵥ p = g₂ +ᵥ p) → g₁ = g₂) → FaithfulVAdd G P | false |
AdjoinRoot.isIntegral_root | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_5} [inst : Field K] {f : Polynomial K}, f ≠ 0 → IsIntegral K (AdjoinRoot.root f) | true |
SimpleGraph.IsTuranMaximal.isEquipartition | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {V : Type u_1} [inst : Fintype V] {G : SimpleGraph V} [inst_1 : DecidableRel G.Adj] {r : ℕ} (h : G.IsTuranMaximal r)
[inst_2 : DecidableEq V], h.finpartition.IsEquipartition | true |
Rack.PreEnvelGroupRel'.inv_mul_cancel.elim | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] →
{motive : (a a_1 : Rack.PreEnvelGroup R) → Rack.PreEnvelGroupRel' R a a_1 → Sort u_1} →
{a a_1 : Rack.PreEnvelGroup R} →
(t : Rack.PreEnvelGroupRel' R a a_1) →
t.ctorIdx = 8 →
((a : Rack.PreEnvelGroup R) →
motive (a.inv.mul a) Ra... | false |
Lean.IR.EmitLLVM.emitSimpleExternalCall | Lean.Compiler.IR.EmitLLVM | {llvmctx : LLVM.Context} →
LLVM.Builder llvmctx →
String →
Array Lean.IR.Param →
Array Lean.IR.Arg → Lean.IR.IRType → String → Lean.IR.EmitLLVM.M llvmctx (LLVM.Value llvmctx) | true |
Set.Finite.compl_mem_hyperfilter | Mathlib.Order.Filter.Ultrafilter.Basic | ∀ {α : Type u} [inst : Infinite α] {s : Set α}, s.Finite → sᶜ ∈ Filter.hyperfilter α | true |
Std.PRange.LawfulUpwardEnumerableLT.ofMap | Init.Data.Range.Polymorphic.Map | ∀ {α : Type u_1} {β : Type u_2} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : Std.PRange.UpwardEnumerable β]
[inst_2 : LT α] [inst_3 : LT β] [Std.PRange.LawfulUpwardEnumerableLT β] (f : Std.PRange.UpwardEnumerable.Map α β)
[f.PreservesLT], Std.PRange.LawfulUpwardEnumerableLT α | true |
LinearOrderedCommGroup.Subgroup.genLTOne_zpowers_eq_top | Mathlib.Algebra.Order.Group.Cyclic | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedMonoid G] (H : Subgroup G)
[inst_3 : Nontrivial ↥H] [hH : IsCyclic ↥H], Subgroup.zpowers (LinearOrderedCommGroup.Subgroup.genLTOne H) = H | true |
Lean.Elab.TermInfo.rec | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.TermInfo → Sort u} →
((toElabInfo : Lean.Elab.ElabInfo) →
(lctx : Lean.LocalContext) →
(expectedType? : Option Lean.Expr) →
(expr : Lean.Expr) →
(isBinder isDisplayableTerm : Bool) →
motive
{ toElabInfo := toElabInfo, lctx := lctx, ... | false |
Prod.instPreorder.match_7 | Mathlib.Order.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (x : α × β) (fst : α) (snd : β)
(motive : (x_1 : α × β) → x_1 ≤ x → (fst, snd) ≤ x_1 → Prop) (x_1 : α × β) (x_2 : x_1 ≤ x) (x_3 : (fst, snd) ≤ x_1),
(∀ (fst_1 : α) (snd_1 : β) (x : (fst_1, snd_1) ≤ x) (x_4 : (fst, snd) ≤ (fst_1, snd_1)),
... | false |
IsLocalizedModule.mk'_cancel_right | Mathlib.Algebra.Module.LocalizedModule.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Submonoid R} {M : Type u_2} {M' : Type u_3} [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid M'] [inst_3 : Module R M] [inst_4 : Module R M'] (f : M →ₗ[R] M')
[inst_5 : IsLocalizedModule S f] (m : M) (s₁ s₂ : ↥S),
IsLocalizedModule.mk' f (s₂ • m) (s₁ * s₂) = IsLocal... | true |
CategoryTheory.Functor.mapTriangulatedSpectralObject._proof_1 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {C : Type u_6} [inst : CategoryTheory.Category.{u_5, u_6} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
{D : Type u_2}... | false |
instLatticeSubtypeIsIdempotentElem._proof_4 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a b : { a // IsIdempotentElem a }), IsIdempotentElem (↑a + ↑b - ↑a * ↑b) | false |
UInt64.toBitVec_zero | Init.Data.UInt.Lemmas | UInt64.toBitVec 0 = 0#64 | true |
Lean.Compiler.LCNF.NormFVarResult.ctorElim | Lean.Compiler.LCNF.CompilerM | {motive : Lean.Compiler.LCNF.NormFVarResult → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Compiler.LCNF.NormFVarResult) →
ctorIdx = t.ctorIdx → Lean.Compiler.LCNF.NormFVarResult.ctorElimType ctorIdx → motive t | false |
Module.IsTorsionFree | Mathlib.Algebra.Module.Torsion.Free | (R : Type u_1) → (M : Type u_3) → [inst : Semiring R] → [inst_1 : AddCommMonoid M] → [Module R M] → Prop | true |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.toNatLit?.match_1 | Lean.Meta.DiscrTree.Main | (motive : OptionT Id ℕ → Sort u_1) →
(x : OptionT Id ℕ) → ((n : ℕ) → motive (some n)) → ((x : OptionT Id ℕ) → motive x) → motive x | false |
norm_eq_zero'._simp_2 | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_5} [inst : NormedGroup E] {a : E}, (‖a‖ = 0) = (a = 1) | false |
_private.Mathlib.Analysis.Calculus.ContDiff.Bounds.0.norm_iteratedFDeriv_clm_apply_const._simp_1_1 | Mathlib.Analysis.Calculus.ContDiff.Bounds | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{n : ℕ}, iteratedFDeriv 𝕜 n f = iteratedFDerivWithin 𝕜 n f Set.univ | false |
CategoryTheory.Limits.biprod.map | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | {C : Type uC} →
[inst : CategoryTheory.Category.{uC', uC} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{W X Y Z : C} →
[inst_2 : CategoryTheory.Limits.HasBinaryBiproduct W X] →
[inst_3 : CategoryTheory.Limits.HasBinaryBiproduct Y Z] → (W ⟶ Y) → (X ⟶ Z) → (W ⊞ X ⟶ Y ⊞ Z) | true |
_private.Lean.Widget.InteractiveDiagnostic.0.Lean.Widget.EmbedFmt.code.sizeOf_spec | Lean.Widget.InteractiveDiagnostic | ∀ (ctx : Lean.Elab.ContextInfo) (infos : Std.TreeMap ℕ Lean.Elab.Info compare),
sizeOf (Lean.Widget.EmbedFmt.code✝ ctx infos) = 1 + sizeOf ctx + sizeOf infos | true |
_private.Std.Sat.AIG.RelabelNat.0.Std.Sat.AIG.RelabelNat.State.Inv2.property._proof_1_2 | Std.Sat.AIG.RelabelNat | ∀ {α : Type} (decls : Array (Std.Sat.AIG.Decl α)) (idx : ℕ) {idx' : ℕ}, idx < idx' + 1 → ¬idx ≤ idx' → False | false |
UpperHalfPlane.σ_conj | Mathlib.Analysis.Complex.UpperHalfPlane.MoebiusAction | ∀ (g : GL (Fin 2) ℝ) (z : ℂ), (UpperHalfPlane.σ g) ((starRingEnd ℂ) z) = (starRingEnd ℂ) ((UpperHalfPlane.σ g) z) | true |
ContinuousLinearMap.evalL_apply | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜] {E : Type u_2} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [inst_5 : IsTopologicalAddGroup E] [inst_6 : ContinuousSMul 𝕜 E]
[inst_7 : FiniteDimensional 𝕜 E] [inst_8 : T2Space E] {F : Type u_3} [ins... | true |
Lean.Compiler.LCNF.Internalize.internalizeFunDecl._unsafe_rec | Lean.Compiler.LCNF.Internalize | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.FunDecl pu → Lean.Compiler.LCNF.Internalize.InternalizeM pu (Lean.Compiler.LCNF.FunDecl pu) | false |
_private.Mathlib.Algebra.BigOperators.Group.Finset.Interval.0.Finset.prod_Icc_of_even_eq_range._proof_1_1 | Mathlib.Algebra.BigOperators.Group.Finset.Interval | ∀ (N : ℕ), ¬-(↑N + 1) = ↑N + 1 | false |
List.replaceF_cons | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Option α} (a : α) (l : List α),
List.replaceF p (a :: l) =
match p a with
| none => a :: List.replaceF p l
| some a' => a' :: l | true |
Std.LawfulCmp.recOn | Batteries.Classes.Order | {α : Type u_1} →
[inst : LE α] →
[inst_1 : LT α] →
{cmp : α → α → Ordering} →
{motive : Std.LawfulCmp cmp → Sort u} →
(t : Std.LawfulCmp cmp) →
([toTransCmp : Std.TransCmp cmp] →
[toLawfulEqCmp : Std.LawfulEqCmp cmp] →
(eq_lt_iff_lt : ∀ {x y : ... | false |
AddSubgroup.le_pi_iff | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {η : Type u_7} {f : η → Type u_8} [inst : (i : η) → AddGroup (f i)] {I : Set η} {H : (i : η) → AddSubgroup (f i)}
{J : AddSubgroup ((i : η) → f i)},
J ≤ AddSubgroup.pi I H ↔ ∀ i ∈ I, J ≤ AddSubgroup.comap (Pi.evalAddMonoidHom f i) (H i) | true |
Con.conGen_eq | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Mul M] (r : M → M → Prop), conGen r = sInf {s | ∀ (x y : M), r x y → s x y} | true |
Lean.Elab.Tactic.BVDecide.Frontend.instToExprBVPred | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | Lean.ToExpr Std.Tactic.BVDecide.BVPred | true |
PProd.rec | Init.Prelude | {α : Sort u} →
{β : Sort v} → {motive : α ×' β → Sort u_1} → ((fst : α) → (snd : β) → motive ⟨fst, snd⟩) → (t : α ×' β) → motive t | false |
Std.DTreeMap.Internal.Const.RcoSliceData.range | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} → {β : Type v} → [inst : Ord α] → Std.DTreeMap.Internal.Const.RcoSliceData α β → Std.Rco α | true |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.MethodsRef.toMethods.unsafe_impl_3 | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.MethodsRef → Lean.Meta.Grind.Methods | true |
Lean.instSizeOfName._@.Mathlib.Util.CompileInductive.1320556760._hygCtx._hyg.3 | Mathlib.Util.CompileInductive | SizeOf Lean.Name | false |
HeytAlg.recOn | Mathlib.Order.Category.HeytAlg | {motive : HeytAlg → Sort u} →
(t : HeytAlg) →
((carrier : Type u_1) → [str : HeytingAlgebra carrier] → motive { carrier := carrier, str := str }) → motive t | false |
_private.Mathlib.Data.DFinsupp.Defs.0.DFinsupp.mk_injective._proof_1_1 | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u_2} {β : ι → Type u_1} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (s : Finset ι)
⦃x y : (i : ↑↑s) → β ↑i⦄, DFinsupp.mk s x = DFinsupp.mk s y → ∀ (i : ↑↑s), (DFinsupp.mk s x) ↑i = (DFinsupp.mk s y) ↑i | false |
FractionalIdeal.spanSingleton_inv_mul | Mathlib.RingTheory.FractionalIdeal.Inverse | ∀ (K : Type u_3) [inst : Field K] {R₁ : Type u_4} [inst_1 : CommRing R₁] [inst_2 : IsDomain R₁] [inst_3 : Algebra R₁ K]
[inst_4 : IsFractionRing R₁ K] {x : K},
x ≠ 0 →
(FractionalIdeal.spanSingleton (nonZeroDivisors R₁) x)⁻¹ * FractionalIdeal.spanSingleton (nonZeroDivisors R₁) x = 1 | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc.0.CategoryTheory.Limits._aux_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc___macroRules__private_Mathlib_CategoryTheory_Limits_Shapes_Pullback_Assoc_0_CategoryTheory_Limits_termW_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Assoc | Lean.Macro | false |
zsmul_neg' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionMonoid α] (a : α) (n : ℤ), n • -a = -n • a | true |
CategoryTheory.LaxBraidedFunctor.laxBraided._autoParam | Mathlib.CategoryTheory.Monoidal.Braided.Basic | Lean.Syntax | false |
lowerSemicontinuous_iff_isClosed_epigraph | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {γ : Type u_4} [inst_1 : LinearOrder γ] [inst_2 : TopologicalSpace γ]
[ClosedIciTopology γ] {f : α → γ}, LowerSemicontinuous f ↔ IsClosed {p | f p.1 ≤ p.2} | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.infer.collectLetValue._sparseCasesOn_1 | Lean.Compiler.LCNF.InferBorrow | {pu : Lean.Compiler.LCNF.Purity} →
{motive : Lean.Compiler.LCNF.LetValue pu → Sort u} →
(t : Lean.Compiler.LCNF.LetValue pu) →
((n : ℕ) →
(var : Lean.FVarId) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.LetValue.reset n var h)) →
((var : Lean.FVarI... | false |
Asymptotics.isTheta_norm_left | Mathlib.Analysis.Asymptotics.Theta | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{f' : α → E'} {l : Filter α}, (fun x => ‖f' x‖) =Θ[l] g ↔ f' =Θ[l] g | true |
Lean.Parser.Command.classInductive.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | true |
_private.Mathlib.Algebra.Category.Grp.EpiMono.0.GrpCat.SurjectiveOfEpiAuxs._aux_Mathlib_Algebra_Category_Grp_EpiMono___unexpand_Equiv_Perm_1 | Mathlib.Algebra.Category.Grp.EpiMono | Lean.PrettyPrinter.Unexpander | false |
Even.neg_zpow | Mathlib.Algebra.Ring.Parity | ∀ {α : Type u_2} [inst : DivisionMonoid α] [inst_1 : HasDistribNeg α] {n : ℤ}, Even n → ∀ (a : α), (-a) ^ n = a ^ n | true |
Associated.neg_left_iff | Mathlib.Algebra.Ring.Associated | ∀ {M : Type u_1} [inst : Monoid M] [inst_1 : HasDistribNeg M] {a b : M}, Associated (-a) b ↔ Associated a b | true |
Std.TreeSet.mem_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a : α},
a ∈ t.insert k ↔ cmp k a = Ordering.eq ∨ a ∈ t | true |
DomMulAct.instDistribMulActionSubtypeAEEqFunMemAddSubgroupLp._proof_3 | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | ∀ {α : Type u_1} {E : Type u_2} [inst : MeasurableSpace α] [inst_1 : NormedAddCommGroup E] {μ : MeasureTheory.Measure α}
{p : ENNReal} (x x_1 : ↥(MeasureTheory.Lp E p μ)),
{ toFun := fun self => self.1, map_zero' := ⋯ }.toFun (x + x_1) =
{ toFun := fun self => self.1, map_zero' := ⋯ }.toFun (x + x_1) | false |
IntermediateField.fg_top | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | ∀ (F : Type u_1) [inst : Field F] (E : Type u_2) [inst_1 : Field E] [inst_2 : Algebra F E] [Algebra.EssFiniteType F E],
⊤.FG | true |
Std.Iter.anyM | Init.Data.Iterators.Consumers.Loop | {α β : Type w} →
{m : Type → Type w'} →
[Monad m] → [inst : Std.Iterator α Id β] → [Std.IteratorLoop α Id m] → (β → m Bool) → Std.Iter β → m Bool | true |
CategoryTheory.Under.postAdjunctionLeft._proof_2 | Mathlib.CategoryTheory.Comma.Over.Basic | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {X : T} {F : CategoryTheory.Functor T D}
{G : CategoryTheory.Functor D T} (a : F ⊣ G) (A : CategoryTheory.Under ((CategoryTheory.Functor.id T).obj X)),
CategoryTheory.CategoryStruct.comp
... | false |
Pell.xz_succ_succ | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (n : ℕ), Pell.xz a1 (n + 2) = ↑(2 * a) * Pell.xz a1 (n + 1) - Pell.xz a1 n | true |
List.dropSlice_sublist | Mathlib.Data.List.Infix | ∀ {α : Type u_1} (n m : ℕ) (l : List α), (List.dropSlice n m l).Sublist l | true |
_private.Mathlib.Topology.Sets.CompactOpenCovered.0.IsCompactOpenCovered.exists_mem_of_isBasis._simp_1_1 | Mathlib.Topology.Sets.CompactOpenCovered | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
_private.Mathlib.Computability.Primrec.Basic.0.Encodable.decodeSum.match_1.splitter._sparseCasesOn_2 | Mathlib.Computability.Primrec.Basic | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
AddCommMonoid.casesOn | Mathlib.Algebra.Group.Defs | {M : Type u} →
{motive : AddCommMonoid M → Sort u_1} →
(t : AddCommMonoid M) →
([toAddMonoid : AddMonoid M] →
(add_comm : ∀ (a b : M), a + b = b + a) → motive { toAddMonoid := toAddMonoid, add_comm := add_comm }) →
motive t | false |
Convex.combo_self_interior_mem_interior | Mathlib.Analysis.Convex.Topology | ∀ {𝕜 : Type u_2} {E : Type u_3} [inst : Field 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [IsTopologicalAddGroup E] [ContinuousConstSMul 𝕜 E] {s : Set E},
Convex 𝕜 s → ∀ {x y : E}, x ∈ s → y ∈ interior s → ∀ {a b : 𝕜}, 0 ≤ a → 0 < b → a + b = 1 →... | true |
CategoryTheory.Pretriangulated.Triangle.π₂Toπ₃._proof_2 | Mathlib.CategoryTheory.Triangulated.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.HasShift C ℤ]
⦃X Y : CategoryTheory.Pretriangulated.Triangle C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Pretriangulated.Triangle.π₂.map f) Y.mor₂ =
CategoryTheory.CategoryStruct.comp X.mor₂ (CategoryT... | false |
CategoryTheory.Subobject.Classifier.isTerminalΩ₀ | Mathlib.CategoryTheory.Subobject.Classifier.Defs | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{c : CategoryTheory.Subobject.Classifier C} → CategoryTheory.Limits.IsTerminal c.Ω₀ | true |
Lean.Parser.Command.GrindCnstr.notValue | Lean.Meta.Tactic.Grind.Parser | Lean.Parser.Parser | true |
NumberField.maximalRealSubfield | Mathlib.NumberTheory.NumberField.InfinitePlace.TotallyRealComplex | (K : Type u_2) → [inst : Field K] → Subfield K | true |
CategoryTheory.Limits.IsLimit.OfNatIso.coneOfHom | Mathlib.CategoryTheory.Limits.IsLimit | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor J C} →
{X : C} → F.cones.RepresentableBy X → {Y : C} → (Y ⟶ X) → CategoryTheory.Limits.Cone F | true |
AccPt.clusterPt | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {F : Filter X}, AccPt x F → ClusterPt x F | true |
eq_or_lt_of_not_gt | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, ¬b < a → a = b ∨ a < b | true |
OrderIso.inv | Mathlib.Algebra.Order.Group.OrderIso | (α : Type u) → [inst : Group α] → [inst_1 : LE α] → [MulLeftMono α] → [MulRightMono α] → α ≃o αᵒᵈ | true |
Real.logDeriv_sin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | logDeriv Real.sin = Real.cot | true |
List.span.loop.eq_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (x : List α), List.span.loop p [] x = (x.reverse, []) | true |
Id.instOfNat._aux_1 | Init.Control.Id | {α : Type u_1} → {n : ℕ} → [OfNat α n] → OfNat (Id α) n | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.size_filter_eq_size_iff._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
NNReal.one_rpow | Mathlib.Analysis.SpecialFunctions.Pow.NNReal | ∀ (x : ℝ), 1 ^ x = 1 | true |
instStarAddMonoidWithConvMatrix._proof_1 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : AddMonoid α] [inst_1 : StarAddMonoid α]
(x x_1 : WithConv (Matrix m n α)), star (x + x_1) = star x + star x_1 | false |
_private.Lean.Meta.Sym.Simp.EvalGround.0.Lean.Meta.Sym.Simp.evalBinBoolPredUInt32 | Lean.Meta.Sym.Simp.EvalGround | (UInt32 → UInt32 → Bool) → Lean.Expr → Lean.Expr → Lean.Meta.Sym.Simp.SimpM Lean.Meta.Sym.Simp.Result | true |
_private.Mathlib.Geometry.Manifold.ContMDiff.Defs.0.contMDiff_congr._simp_1_1 | Mathlib.Geometry.Manifold.ContMDiff.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | false |
_private.Init.Data.Format.Basic.0.Std.Format.be.match_4 | Init.Data.Format.Basic | (motive : Std.Format.FlattenBehavior → Sort u_1) →
(x : Std.Format.FlattenBehavior) →
(Unit → motive Std.Format.FlattenBehavior.allOrNone) → (Unit → motive Std.Format.FlattenBehavior.fill) → motive x | false |
_private.Mathlib.Data.List.Basic.0.List.getLast_append_of_right_ne_nil._proof_1_3 | Mathlib.Data.List.Basic | ∀ {α : Type u_1} (l₂ : List α) (h : l₂ ≠ []), ([] ++ l₂).getLast ⋯ = l₂.getLast h | false |
Finset.eq_singleton_iff_nonempty_unique_mem | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {s : Finset α} {a : α}, s = {a} ↔ s.Nonempty ∧ ∀ x ∈ s, x = a | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.