name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Combinatorics.Enumerative.IncidenceAlgebra.0.IncidenceAlgebra.muFun'._proof_1 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] (b a : α) (x : ↥(Finset.Ioc a b)), a < ↑x ∧ ↑x ≤ b | false |
DivisionRing.toNNRatCast | Mathlib.Algebra.Field.Defs | {K : Type u_2} → [self : DivisionRing K] → NNRatCast K | true |
_private.Init.Data.Option.Lemmas.0.Option.choice.eq_1 | Init.Data.Option.Lemmas | ∀ (α : Type u_1), Option.choice α = if h : Nonempty α then some (Classical.choice h) else none | true |
CategoryTheory.Limits.zeroProdIso_inv_snd | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.zeroProdIso X).inv CategoryTheory.Limits.prod.snd =
CategoryTheory.CategoryStruct... | true |
SheafOfModules.relationsOfIsCokernelFree_s | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddCommG... | true |
AddCon.instInfSet._proof_2 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Add M] (S : Set (AddCon M)) {w x y z : M},
(∀ c ∈ S, c w x) → (∀ c ∈ S, c y z) → ∀ c ∈ S, c (w + y) (x + z) | false |
OnePoint.instFintype._proof_3 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : Fintype X] (x : OnePoint X), x ∈ OnePoint.instFintype._aux_1 | false |
Int.fract_div_mul_self_add_zsmul_eq | Mathlib.Algebra.Order.Floor.Ring | ∀ {k : Type u_4} [inst : Field k] [inst_1 : LinearOrder k] [inst_2 : FloorRing k] (a b : k),
a ≠ 0 → Int.fract (b / a) * a + ⌊b / a⌋ • a = b | true |
UInt16.reduceOfNatLT._regBuiltin.UInt16.reduceOfNatLT.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.1661162788._hygCtx._hyg.322 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | false |
Lean.Parser.Command.openHiding.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | true |
Lean.Widget.TaggedText.rec_1 | Lean.Widget.TaggedText | {α : Type u} →
{motive_1 : Lean.Widget.TaggedText α → Sort u_1} →
{motive_2 : Array (Lean.Widget.TaggedText α) → Sort u_1} →
{motive_3 : List (Lean.Widget.TaggedText α) → Sort u_1} →
((a : String) → motive_1 (Lean.Widget.TaggedText.text a)) →
((a : Array (Lean.Widget.TaggedText α)) → motiv... | false |
MonoidWithZero.mk | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
[toMonoid : Monoid M₀] → [toZero : Zero M₀] → (∀ (a : M₀), 0 * a = 0) → (∀ (a : M₀), a * 0 = 0) → MonoidWithZero M₀ | true |
Std.DTreeMap.Raw.get_union_of_not_mem_left | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap.Raw α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] (h₁ : t₁.WF) (h₂ : t₂.WF) {k : α} (not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂},
(t₁ ∪ t₂).get k h' = t₂.get k ⋯ | true |
FirstOrder.Language.Formula.realize_iSup | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {β : Type v'} [inst_1 : Finite β]
{f : β → L.Formula α} {v : α → M}, (FirstOrder.Language.Formula.iSup f).Realize v ↔ ∃ b, (f b).Realize v | true |
CategoryTheory.Sigma.SigmaHom.ctorIdx | Mathlib.CategoryTheory.Sigma.Basic | {I : Type w₁} →
{C : I → Type u₁} →
{inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)} →
{a a_1 : (i : I) × C i} → CategoryTheory.Sigma.SigmaHom a a_1 → ℕ | false |
_private.Mathlib.Algebra.Ring.Idempotent.0.IsIdempotentElem.sub_iff._simp_1_3 | Mathlib.Algebra.Ring.Idempotent | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b c : α), a - b - c = a - (b + c) | false |
CategoryTheory.ShortComplex.Splitting.ofIsIsoOfIsZero._proof_2 | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(S : CategoryTheory.ShortComplex C) (hf : CategoryTheory.IsIso S.f),
CategoryTheory.CategoryStruct.comp S.f (CategoryTheory.inv S.f) = CategoryTheory.CategoryStruct.id S.X₁ | false |
CategoryTheory.Comma.id_left | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor A T}
{R : CategoryTheory.Functor B T} {X : CategoryTheory.Comma L R},
(CategoryTheory.CategoryStruct.id X)... | true |
CategoryTheory.Abelian.AbelianStruct.mk._flat_ctor | Mathlib.CategoryTheory.Abelian.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_2, u_1} C] →
[inst_1 : CategoryTheory.Preadditive C] →
{X Y : C} →
{f : X ⟶ Y} →
(kernelFork : CategoryTheory.Limits.KernelFork f) →
CategoryTheory.Limits.IsLimit kernelFork →
(cokernelCofork : CategoryTheory.Lim... | false |
zpow_right_strictAnti₀ | Mathlib.Algebra.Order.GroupWithZero.Unbundled.Basic | ∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {a : G₀}
[ZeroLEOneClass G₀], 0 < a → a < 1 → StrictAnti fun n => a ^ n | true |
CategoryTheory.Functor.comp_mapCommGrp_mul | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {D : Type u₂} [inst_3 : CategoryTheory.Category.{v₂, u₂} D]
[inst_4 : CategoryTheory.CartesianMonoidalCategory D] [inst_5 : CategoryTheory.BraidedCategory D] ... | true |
Lean.RBMap.ofList._sunfold | Lean.Data.RBMap | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → List (α × β) → Lean.RBMap α β cmp | false |
_private.Mathlib.CategoryTheory.Sites.Descent.Precoverage.0.CategoryTheory.Pseudofunctor.DescentData.full_pullFunctor.sieve | Mathlib.CategoryTheory.Sites.Descent.Precoverage | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{ι : Type t} →
{S : C} →
{X : ι → C} →
((i : ι) → X i ⟶ S) →
{ι' : Type t'} →
{X' : ι' → C} →
((j : ι') → X' j ⟶ S) →
(i : ι) → CategoryTheory.Sieve (CategoryTheory.Over.m... | true |
_private.Lean.DocString.Extension.0.Lean.initFn._@.Lean.DocString.Extension.797151674._hygCtx._hyg.2 | Lean.DocString.Extension | IO (IO.Ref (Lean.NameMap Lean.VersoDocString)) | false |
_private.Mathlib.Topology.Algebra.InfiniteSum.ENNReal.0.NNReal.tsum_indicator_ne_zero.match_1_1 | Mathlib.Topology.Algebra.InfiniteSum.ENNReal | ∀ {α : Type u_1} {f : α → NNReal} {s : Set α} (motive : (∃ a ∈ s, f a ≠ 0) → Prop) (h : ∃ a ∈ s, f a ≠ 0),
(∀ (a : α) (ha : a ∈ s) (hap : f a ≠ 0), motive ⋯) → motive h | false |
intervalIntegral.integral_deriv_smul_comp_of_deriv_nonpos | Mathlib.MeasureTheory.Integral.IntervalIntegral.IntegrationByParts | ∀ {a b : ℝ} {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f f' : ℝ → ℝ} {g : ℝ → E},
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.Ioo (min a b) (max a b), HasDerivAt f (f' x) x) →
(∀ x ∈ Set.Ioo (min a b) (max a b), f' x ≤ 0) → ∫ (x : ℝ) in a..b, f' x • (g ∘ f) x = ∫ (u : ℝ) in f a.... | true |
CochainComplex.ConnectData.d.eq_1 | Mathlib.Algebra.Homology.Embedding.Connect | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K : ChainComplex C ℕ} {L : CochainComplex C ℕ} (h : CochainComplex.ConnectData K L) (n m : ℕ),
h.d (Int.ofNat n) (Int.ofNat m) = L.d n m | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram.IsTerminal.lift.congr_simp | Mathlib.CategoryTheory.Presentable.Directed | ∀ {J : Type w} [inst : CategoryTheory.SmallCategory J] {κ : Cardinal.{w}}
{D : CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.Diagram J κ} {e : J} (self self_1 : D.IsTerminal e),
self = self_1 → ∀ {j : J} (hj : D.P j), self.lift hj = self_1.lift hj | true |
Std.Roc.mk.sizeOf_spec | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} [inst : SizeOf α] (lower upper : α), (sizeOf lower<...=upper) = 1 + sizeOf lower + sizeOf upper | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toNat_shiftLeftZeroExtend._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (n : ℕ), ¬w < w + (n + 1) → False | false |
FirstOrder.Language.LHom.ofIsEmpty_onRelation | Mathlib.ModelTheory.LanguageMap | ∀ (L : FirstOrder.Language) (L' : FirstOrder.Language) [inst : L.IsAlgebraic] [inst_1 : L.IsRelational] {n : ℕ}
(a : L.Relations n), (FirstOrder.Language.LHom.ofIsEmpty L L').onRelation a = isEmptyElim a | true |
ConvexBody.carrier | Mathlib.Analysis.Convex.Body | {V : Type u_2} → [inst : TopologicalSpace V] → [inst_1 : AddCommMonoid V] → [inst_2 : SMul ℝ V] → ConvexBody V → Set V | true |
Lean.IR.Param.mk | Lean.Compiler.IR.Basic | Lean.IR.VarId → Bool → Lean.IR.IRType → Lean.IR.Param | true |
instSemiringCorner | Mathlib.RingTheory.Idempotents | {R : Type u_1} → (e : R) → [inst : NonUnitalSemiring R] → (idem : IsIdempotentElem e) → Semiring idem.Corner | true |
IntermediateField.inf_relrank_left | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] (A B : IntermediateField F E),
(A ⊓ B).relrank A = B.relrank A | true |
CategoryTheory.ShrinkHoms.hasLimitsOfShape | Mathlib.CategoryTheory.Abelian.Transfer | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.LocallySmall.{w, v_1, u_1} C]
(J : Type u_2) [inst_2 : CategoryTheory.Category.{v_2, u_2} J] [CategoryTheory.Limits.HasLimitsOfShape J C],
CategoryTheory.Limits.HasLimitsOfShape J (CategoryTheory.ShrinkHoms.{u_1} C) | true |
MeasureTheory.AEDisjoint | Mathlib.MeasureTheory.Measure.AEDisjoint | {α : Type u_2} → {m : MeasurableSpace α} → MeasureTheory.Measure α → Set α → Set α → Prop | true |
RingTheory.Sequence.IsRegular.recIterModByRegular.match_1 | Mathlib.RingTheory.Regular.RegularSequence | {R : Type u_1} →
[inst : CommRing R] →
{M : Type u_2} →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(r : R) →
(rs' : List R) →
(motive : IsSMulRegular M r ∧ RingTheory.Sequence.IsRegular (QuotSMulTop r M) rs' → Sort u_3) →
(x : IsSMulRegula... | false |
CategoryTheory.Limits.limitBiconeOfUnique_bicone_π | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_2 : Unique J] (f : J → C) (j : J),
(CategoryTheory.Limits.limitBiconeOfUnique f).bicone.π j = CategoryTheory.eqToHom ⋯ | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr.0.Lean.Meta.Grind.Arith.CommRing.denoteExprCore.go | Lean.Meta.Tactic.Grind.Arith.CommRing.DenoteExpr | {M : Type → Type} →
[Monad M] →
[Lean.MonadError M] →
[MonadLiftT Lean.MetaM M] →
[Lean.Meta.Grind.Arith.CommRing.MonadCanon M] →
[Lean.Meta.Grind.Arith.CommRing.MonadRing M] →
(ℕ → Lean.Expr) → Lean.Meta.Grind.Arith.CommRing.RingExpr → M Lean.Expr | true |
_private.Mathlib.Data.Real.ENatENNReal.0.ENat.toENNReal_eq_top._simp_1_1 | Mathlib.Data.Real.ENatENNReal | ∀ {m n : ℕ∞}, (m = n) = (↑m = ↑n) | false |
LeftInvariantDerivation.instAdd | Mathlib.Geometry.Manifold.Algebra.LeftInvariantDerivation | {𝕜 : 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} →
{G : Type u_4} →
... | true |
instAddCommMonoidEReal | Mathlib.Data.EReal.Basic | AddCommMonoid EReal | true |
Matrix.mul_adjp_apply_ne | Mathlib.LinearAlgebra.Matrix.SemiringInverse | ∀ {n : Type u_1} {R : Type u_3} [inst : Fintype n] [inst_1 : DecidableEq n] [inst_2 : CommSemiring R] (A : Matrix n n R)
(i j : n), i ≠ j → (A * Matrix.adjp 1 A) i j = (A * Matrix.adjp (-1) A) i j | true |
isFiniteLength_iff_isNoetherian_isArtinian | Mathlib.RingTheory.FiniteLength | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
IsFiniteLength R M ↔ IsNoetherian R M ∧ IsArtinian R M | true |
continuousAt_id' | Mathlib.Topology.Continuous | ∀ {X : Type u_1} [inst : TopologicalSpace X] (y : X), ContinuousAt (fun x => x) y | true |
CategoryTheory.Functor.FullyFaithful.id._proof_2 | Mathlib.CategoryTheory.Functor.FullyFaithful | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y),
(CategoryTheory.Functor.id C).map f = f | false |
HomotopicalAlgebra.Cylinder.instIsGoodTrans | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {A : C}
[inst_2 : HomotopicalAlgebra.IsCofibrant A] (P P' : HomotopicalAlgebra.Cylinder A) [P.IsGood] [inst_4 : P'.IsGood],
(P.trans P').IsGood | true |
LieIdeal.mem_map_of_surjective | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L} {y : L'},
Function.Surjective ⇑f → y ∈ LieIdeal.map f I → ∃ x, f ↑x = y | true |
ProbabilityTheory.stieltjesOfMeasurableRat | Mathlib.Probability.Kernel.Disintegration.MeasurableStieltjes | {α : Type u_1} → [inst : MeasurableSpace α] → (f : α → ℚ → ℝ) → Measurable f → α → StieltjesFunction ℝ | true |
Complex.I_mul_re | Mathlib.Data.Complex.Basic | ∀ (z : ℂ), (Complex.I * z).re = -z.im | true |
withPtrAddr | Init.Util | {α : Type u} → {β : Type v} → α → (k : USize → β) → (∀ (u₁ u₂ : USize), k u₁ = k u₂) → β | true |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Datatypes.0.Mathlib.Tactic.BicategoryLike.Mor₂Iso.e.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Datatypes | (motive : Mathlib.Tactic.BicategoryLike.Mor₂Iso → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.Mor₂Iso) →
((α : Mathlib.Tactic.BicategoryLike.StructuralAtom) →
motive (Mathlib.Tactic.BicategoryLike.Mor₂Iso.structuralAtom α)) →
((e : Lean.Expr) →
(f g h : Mathlib.Tactic.BicategoryLike.Mor... | false |
Set.WellFoundedOn.union | Mathlib.Order.WellFoundedSet | ∀ {α : Type u_2} {r : α → α → Prop} [IsStrictOrder α r] {s t : Set α},
s.WellFoundedOn r → t.WellFoundedOn r → (s ∪ t).WellFoundedOn r | true |
Turing.PartrecToTM2.Cont'.comp.elim | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Cont' → Sort u} →
(t : Turing.PartrecToTM2.Cont') →
t.ctorIdx = 3 →
((a : Turing.ToPartrec.Code) →
(a_1 : Turing.PartrecToTM2.Cont') → motive (Turing.PartrecToTM2.Cont'.comp a a_1)) →
motive t | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.mem_insert_self._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | false |
CategoryTheory.Sheaf.coneΓ | Mathlib.CategoryTheory.Sites.GlobalSections | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
[inst_2 : CategoryTheory.HasWeakSheafify J A] →
[CategoryTheory.HasGlobalSectionsFunctor J A] →
... | true |
_private.Mathlib.NumberTheory.NumberField.Units.DirichletTheorem.0.NumberField.Units.fundSystem_mk._simp_1_2 | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {α : Sort u} {β : Sort v} {x : α} {y : β} (f : α ≃ β), (f x = y) = (x = f.symm y) | false |
ProbabilityTheory.Kernel.lintegral_deterministic | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {f : β → ENNReal} {g : α → β} {a : α}
(hg : Measurable g) [MeasurableSingletonClass β],
∫⁻ (x : β), f x ∂(ProbabilityTheory.Kernel.deterministic g hg) a = f (g a) | true |
SimpleGraph.card_edgeFinset_turanGraph_add | Mathlib.Combinatorics.SimpleGraph.Extremal.Turan | ∀ {n r : ℕ},
(SimpleGraph.turanGraph (n + r) r).edgeFinset.card =
(SimpleGraph.turanGraph n r).edgeFinset.card + n * (r - 1) + r.choose 2 | true |
CategoryTheory.MorphismProperty.FunctorialFactorizationData.fac_app_assoc | Mathlib.CategoryTheory.MorphismProperty.Factorization | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {W₁ W₂ : CategoryTheory.MorphismProperty C}
(data : W₁.FunctorialFactorizationData W₂) {f : CategoryTheory.Arrow C} {Z : C}
(h : CategoryTheory.Arrow.rightFunc.obj f ⟶ Z),
CategoryTheory.CategoryStruct.comp (data.i.app f) (CategoryTheory.CategoryStruc... | true |
_private.Mathlib.Data.Fin.VecNotation.0.Matrix.vecAlt0_vecAppend._proof_1_4 | Mathlib.Data.Fin.VecNotation | ∀ {n : ℕ} (i : Fin n), ↑i + ↑i - n < n | false |
NonUnitalSubsemiring.centralizer._proof_2 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] (s : Set R), 0 ∈ s.centralizer | false |
Subtype.instLocallyFiniteOrder._proof_5 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] (p : α → Prop) [inst_1 : DecidablePred p] [inst_2 : LocallyFiniteOrder α]
(a b x : Subtype p), x ∈ Finset.subtype p (Finset.Ico ↑a ↑b) ↔ a ≤ x ∧ x < b | false |
AlgEquiv.ofLinearEquiv._proof_1 | Mathlib.Algebra.Algebra.Equiv | ∀ {R : Type u_3} {A₁ : Type u_1} {A₂ : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] (l : A₁ ≃ₗ[R] A₂), Function.LeftInverse l.invFun (↑l).toFun | false |
_private.Mathlib.Data.Nat.MaxPowDiv.0.Nat.pow_dvd_iff_le_padicValNat._proof_1_1 | Mathlib.Data.Nat.MaxPowDiv | ∀ {p : ℕ}, p ≠ 1 → p = 0 ∨ 1 < p | false |
Std.DTreeMap.toList_roc._auto_1 | Std.Data.DTreeMap.Slice | Lean.Syntax | false |
_private.Mathlib.Order.Antichain.0.«term_≺_» | Mathlib.Order.Antichain | Lean.TrailingParserDescr | true |
BoxIntegral.Prepartition.iUnion_ofWithBot | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} (boxes : Finset (WithBot (BoxIntegral.Box ι)))
(le_of_mem : ∀ J ∈ boxes, J ≤ ↑I) (pairwise_disjoint : (↑boxes).Pairwise Disjoint),
(BoxIntegral.Prepartition.ofWithBot boxes le_of_mem pairwise_disjoint).iUnion = ⋃ J ∈ boxes, ↑J | true |
MeasureTheory.Measure.eqOn_Icc_of_ae_eq | Mathlib.MeasureTheory.Measure.OpenPos | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : LinearOrder X] [OrderTopology X]
{m : MeasurableSpace X} [inst_3 : TopologicalSpace Y] [T2Space Y] (μ : MeasureTheory.Measure X) [μ.IsOpenPosMeasure]
[DenselyOrdered X] {a b : X},
a ≠ b →
∀ {f g : X → Y},
f =ᵐ[μ.restrict (Set.Icc a b)... | true |
Complex.summable_ofReal._simp_1 | Mathlib.Analysis.Complex.Basic | ∀ {α : Type u_1} {L : SummationFilter α} {f : α → ℝ}, Summable (fun x => ↑(f x)) L = Summable f L | false |
Group.fg_iff_subgroup_fg._simp_2 | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (H : Subgroup G), Group.FG ↥H = H.FG | false |
AddSubmonoid.isOpen_addUnits | Mathlib.Topology.Algebra.Group.Units | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddMonoid M] {U : AddSubmonoid M}, IsOpen ↑U → IsOpen ↑U.addUnits | true |
BitVec.ofBoolListBE | Init.Data.BitVec.Basic | (bs : List Bool) → BitVec bs.length | true |
ZFSet.IsOrdinal.subset_iff_eq_or_mem | Mathlib.SetTheory.ZFC.Ordinal | ∀ {x y : ZFSet.{u}}, x.IsOrdinal → y.IsOrdinal → (x ⊆ y ↔ x = y ∨ x ∈ y) | true |
_private.Init.Data.Array.BasicAux.0.Array.mapM'.go.eq_def | Init.Data.Array.BasicAux | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (as : Array α) (i : ℕ)
(acc : { bs // bs.size = i }) (hle : i ≤ as.size),
Array.mapM'.go✝ f as i acc hle =
if h : i = as.size then pure (h ▸ acc)
else
have hlt := ⋯;
do
let b ← f as[i]
Array.mapM... | true |
instCountableFreeMonoid | Mathlib.SetTheory.Cardinal.Free | ∀ (α : Type u) [Countable α], Countable (FreeMonoid α) | true |
_private.Aesop.Saturate.0.Aesop.saturateCore.runRule | Aesop.Saturate | {α : Type} →
Lean.MVarId →
Aesop.UnorderedArraySet Lean.MVarId →
Lean.Meta.SavedState →
Aesop.IndexMatchResult (Aesop.Rule α) →
Aesop.SaturateM (Option (Aesop.GoalDiff × Option (Array Aesop.Script.LazyStep))) | true |
Pi.nonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Pi | ∀ {I : Type u_1} {f : I → Type u_2} [inst : (i : I) → NonAssocSemiring (f i)] (a : (i : I) → f i), a * 1 = a | false |
_private.Mathlib.Combinatorics.Enumerative.DyckWord.0.DyckWord.IsNested.nest._proof_1_3 | Mathlib.Combinatorics.Enumerative.DyckWord | ∀ {p : DyckWord}, ∀ i < 1 + (↑p).length + 1, i ≤ (↑p).length + 1 | false |
Std.DTreeMap.Internal.Impl.getKeyD_minKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.minKey! fallback = t.minKey! | true |
Graph.IsLoopAt.eq_of_inc | Mathlib.Combinatorics.Graph.Basic | ∀ {α : Type u_1} {β : Type u_2} {x y : α} {e : β} {G : Graph α β}, G.IsLoopAt e x → G.Inc e y → x = y | true |
_private.Mathlib.Data.Multiset.Powerset.0.Multiset.bind_powerset_len._simp_1_2 | Mathlib.Data.Multiset.Powerset | ∀ {β : Type u_1} {γ : Type u_2} {α : Type u_3} {f : β → γ} {g : α → List β} {l : List α},
List.flatMap (fun a => List.map f (g a)) l = List.map f (List.flatMap g l) | false |
_private.Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence.0.Mathlib.Tactic.Bicategory.«term_▷_» | Mathlib.Tactic.CategoryTheory.Bicategory.PureCoherence | Lean.TrailingParserDescr | true |
Action.FunctorCategoryEquivalence.functor_μ | Mathlib.CategoryTheory.Action.Monoidal | ∀ (V : Type u_1) [inst : CategoryTheory.Category.{v_1, u_1} V] (G : Type u_2) [inst_1 : Monoid G]
[inst_2 : CategoryTheory.MonoidalCategory V] (A B : Action V G),
CategoryTheory.Functor.LaxMonoidal.μ Action.FunctorCategoryEquivalence.functor A B =
CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalC... | true |
Bimod.RightUnitorBimod.hom._proof_2 | Mathlib.CategoryTheory.Monoidal.Bimod | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[CategoryTheory.Limits.HasCoequalizers C] {R S : CategoryTheory.Mon C} (P : Bimod R S),
CategoryTheory.Limits.HasColimit
(CategoryTheory.Limits.parallelPair
(CategoryTheory.MonoidalCategoryStruct.wh... | false |
RCLike.sqrt_of_nonneg | Mathlib.Analysis.RCLike.Sqrt | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {a : 𝕜}, 0 ≤ a → RCLike.sqrt a = ↑√(RCLike.re a) | true |
Lean.Lsp.SignatureHelpParams.toTextDocumentPositionParams | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.SignatureHelpParams → Lean.Lsp.TextDocumentPositionParams | true |
MvPowerSeries.instAddGroup | Mathlib.RingTheory.MvPowerSeries.Basic | {σ : Type u_1} → {R : Type u_2} → [AddGroup R] → AddGroup (MvPowerSeries σ R) | true |
OrderHom.antisymmetrization._proof_1 | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β)
(a b : Antisymmetrization α fun x1 x2 => x1 ≤ x2), a ≤ b → Quotient.map' ⇑f ⋯ a ≤ Quotient.map' ⇑f ⋯ b | false |
String.Slice.Pos.offset_cast | Init.Data.String.Basic | ∀ {s t : String.Slice} {pos : s.Pos} {h : s = t}, (pos.cast h).offset = pos.offset | true |
_private.Mathlib.Order.SuccPred.Basic.0.Order.Ioo_pred_right_eq_insert._simp_1_1 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b = Set.Ioi a ∩ Set.Iio b | false |
Lean.MonadRecDepth.getMaxRecDepth | Lean.Exception | {m : Type → Type} → [self : Lean.MonadRecDepth m] → m ℕ | true |
Aesop.UnsafeRuleInfo.casesOn | Aesop.Rule | {motive : Aesop.UnsafeRuleInfo → Sort u} →
(t : Aesop.UnsafeRuleInfo) →
((successProbability : Aesop.Percent) → motive { successProbability := successProbability }) → motive t | false |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParams.Info.format.match_1 | Lean.Elab.PreDefinition.FixedParams | (motive : Option ℕ → Sort u_1) → (x : Option ℕ) → (Unit → motive none) → ((idx : ℕ) → motive (some idx)) → motive x | false |
Matroid.isBase_restrict_iff._auto_1 | Mathlib.Combinatorics.Matroid.Minor.Restrict | Lean.Syntax | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get?_diff_of_contains_eq_false_right._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | false |
IsEmpty.toEncodable | Mathlib.Logic.Encodable.Basic | {α : Type u_1} → [IsEmpty α] → Encodable α | true |
MvPolynomial.esymmAlgHomMonomial | Mathlib.RingTheory.MvPolynomial.Symmetric.FundamentalTheorem | (σ : Type u_1) → {R : Type u_3} → {n : ℕ} → [inst : CommSemiring R] → [Fintype σ] → (Fin n →₀ ℕ) → R → MvPolynomial σ R | true |
Std.ExtDTreeMap.size_filter_eq_size_iff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {f : (a : α) → β a → Bool},
(Std.ExtDTreeMap.filter f t).size = t.size ↔ ∀ (k : α) (h : k ∈ t), f k (t.get k h) = true | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.