name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.AlgebraicTopology.SimplicialSet.Path.0.SSet.spine_δ₀._simp_1_6 | Mathlib.AlgebraicTopology.SimplicialSet.Path | (SimplexCategory.mk 0).const (SimplexCategory.mk (0 + 1)) 1 = SimplexCategory.δ 0 | false |
CategoryTheory.FunctorToTypes.rightAdj_obj_obj | Mathlib.CategoryTheory.Monoidal.Closed.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type (max w v u))) (X : C),
((CategoryTheory.FunctorToTypes.rightAdj F).obj G).obj X = F.HomObj G (CategoryTheory.coyoneda.obj (Opposite.op X)) | true |
IsEllDivSequence.smul | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] {W : ℤ → R}, IsEllDivSequence W → ∀ (x : R), IsEllDivSequence (x • W) | true |
Plausible.Random.noConfusion | Plausible.Random | {P : Sort u_2} →
{m : Type u → Type u_1} →
{α : Type u} →
{t : Plausible.Random m α} →
{m' : Type u → Type u_1} →
{α' : Type u} →
{t' : Plausible.Random m' α'} → m = m' → α = α' → t ≍ t' → Plausible.Random.noConfusionType P t t' | false |
OpenPartialHomeomorph.MDifferentiable.symm_comp_deriv | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : 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... | true |
Lean.Elab.Term.MatchAltView.ref | Lean.Elab.MatchAltView | {k : Lean.SyntaxNodeKinds} → Lean.Elab.Term.MatchAltView k → Lean.Syntax | true |
CategoryTheory.CartesianClosed.uncurry_curry | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A] (f : CategoryTheory.MonoidalCategoryStruct.tensorObj A X ⟶ Y),
CategoryTheory.MonoidalClosed.uncurry (CategoryTheory.MonoidalClosed.curry f) = f | true |
CommSemiRingCat.limitCommSemiring._proof_6 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommSemiRingCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommSemiRingCat)).sections]
(a : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget CommSemiRingCat))).pt), 0 + a ... | false |
CategoryTheory.yonedaAddMonObj._proof_5 | Mathlib.CategoryTheory.Monoidal.Cartesian.Mon_ | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(M : C) [inst_2 : CategoryTheory.AddMonObj M] (x : Cᵒᵖ),
AddMonCat.ofHom
{ toFun := fun x_1 => CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id x).unop x_1,
map_zero... | false |
HomogeneousLocalization.val_pow | Mathlib.RingTheory.GradedAlgebra.HomogeneousLocalization | ∀ {ι : Type u_1} {A : Type u_2} {σ : Type u_3} [inst : CommRing A] [inst_1 : SetLike σ A]
[inst_2 : AddSubgroupClass σ A] [inst_3 : AddCommMonoid ι] [inst_4 : DecidableEq ι] {𝒜 : ι → σ}
[inst_5 : GradedRing 𝒜] {x : Submonoid A} (y : HomogeneousLocalization 𝒜 x) (n : ℕ), (y ^ n).val = y.val ^ n | true |
String.instDecidableEqPos | Init.Data.String.Defs | {s : String} → DecidableEq s.Pos | true |
LieAdmissibleRing.ctorIdx | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | {L : Type u_1} → LieAdmissibleRing L → ℕ | false |
Lean.Elab.Tactic.instBEqSimpKind.beq | Lean.Elab.Tactic.Simp | Lean.Elab.Tactic.SimpKind → Lean.Elab.Tactic.SimpKind → Bool | true |
Rep.quotientToCoinvariants | Mathlib.RepresentationTheory.Coinvariants | {k : Type u} →
{G : Type v} →
[inst : CommRing k] →
[inst_1 : Group G] → Rep.{w, u, v} k G → (S : Subgroup G) → [inst_2 : S.Normal] → Rep.{w, u, v} k (G ⧸ S) | true |
SubsemiringClass.toSemiring._proof_6 | Mathlib.Algebra.Ring.Subsemiring.Defs | ∀ {S : Type u_2} (s : S) {R : Type u_1} [inst : Semiring R] [inst_1 : SetLike S R] [inst_2 : SubsemiringClass S R],
autoParam (∀ (n : ℕ) (x : ↥s), Monoid.npow (n + 1) x = Monoid.npow n x * x) Monoid.npow_succ._autoParam | false |
ShrinkingLemma.PartialRefinement.find | Mathlib.Topology.ShrinkingLemma | {ι : Type u_1} →
{X : Type u_2} →
[inst : TopologicalSpace X] →
{u : ι → Set X} →
{s : Set X} →
{p : Set X → Prop} →
(c : Set (ShrinkingLemma.PartialRefinement u s p)) → c.Nonempty → ι → ShrinkingLemma.PartialRefinement u s p | true |
_private.Mathlib.FieldTheory.Galois.IsGaloisGroup.0.IsGaloisGroup.subgroup._proof_1 | Mathlib.FieldTheory.Galois.IsGaloisGroup | ∀ (G : Type u_1) (K : Type u_3) (L : Type u_2) [inst : Group G] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra K L] [inst_4 : MulSemiringAction G L] (H : Subgroup G) [hGKL : IsGaloisGroup G K L],
SMulCommClass (↥H) (↥(FixedPoints.intermediateField ↥H)) L | false |
Algebra.IsSeparable.isAlgebraic | Mathlib.FieldTheory.Separable | ∀ (F : Type u_1) (K : Type u_3) [inst : CommRing F] [inst_1 : Ring K] [inst_2 : Algebra F K] [Nontrivial F]
[Algebra.IsSeparable F K], Algebra.IsAlgebraic F K | true |
Std.DHashMap.Internal.Raw₀.interSmallerFnₘ.eq_1 | Std.Data.DHashMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m sofar : Std.DHashMap.Internal.Raw₀ α β) (k : α),
m.interSmallerFnₘ sofar k =
match m.getEntry?ₘ k with
| some kv' => sofar.insertₘ kv'.fst kv'.snd
| none => sofar | true |
starRingEnd | Mathlib.Algebra.Star.Basic | (R : Type u) → [inst : CommSemiring R] → [StarRing R] → R →+* R | true |
_private.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums.0.Lean.Elab.Tactic.BVDecide.Frontend.Normalize.PostProcessState.hyps._default | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Enums | Array Lean.Meta.Hypothesis | false |
Lean.Elab.Term.mkCalcTrans | Lean.Elab.Calc | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.MetaM (Lean.Expr × Lean.Expr) | true |
cantorSetHomeomorphNatToBool._proof_1 | Mathlib.Topology.Instances.CantorSet | Continuous fun x i => bif x i then 2 else 0 | false |
UInt32.toInt32_xor | Init.Data.SInt.Bitwise | ∀ (a b : UInt32), (a ^^^ b).toInt32 = a.toInt32 ^^^ b.toInt32 | true |
_private.Mathlib.Algebra.MvPolynomial.Eval.0.Algebra.adjoin_range_eq_range_aeval._simp_1_3 | Mathlib.Algebra.MvPolynomial.Eval | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | false |
mul_star_self_nonneg._simp_1 | Mathlib.Algebra.Order.Star.Basic | ∀ {R : Type u_1} [inst : NonUnitalSemiring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
(r : R), (0 ≤ r * star r) = True | false |
_private.Mathlib.Analysis.SpecialFunctions.Integrals.Basic.0.integral_sin_sq._simp_1_5 | Mathlib.Analysis.SpecialFunctions.Integrals.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | false |
Std.Iter.Total.toExtTreeSet | Std.Data.Iterators.Consumers.Set | {α β : Type w} →
[inst : Std.Iterator α Id β] →
[Std.Iterators.Finite α Id] →
[Std.IteratorLoop α Id Id] →
Std.Iter.Total β →
(cmp : autoParam (β → β → Ordering) Std.Iter.Total.toExtTreeSet._auto_1) →
[Std.TransCmp cmp] → Std.ExtTreeSet β cmp | true |
WithTop.locallyFiniteOrder._proof_6 | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a b x : WithTop α),
(x ∈
match a, b with
| none, x => ∅
| some a, none => Finset.map Function.Embedding.coeWithTop (Finset.Ici a)
| some a, some b => Finset.map Function.Embedding.coeWithTop (Finset... | false |
_private.Mathlib.Analysis.CStarAlgebra.Module.Defs.0.CStarModule._aux_Mathlib_Analysis_CStarAlgebra_Module_Defs___unexpand_Inner_inner_1 | Mathlib.Analysis.CStarAlgebra.Module.Defs | Lean.PrettyPrinter.Unexpander | false |
AddRightCancelMonoid.ext_iff | Mathlib.Algebra.Group.Ext | ∀ {M : Type u} {m₁ m₂ : AddRightCancelMonoid M}, m₁ = m₂ ↔ HAdd.hAdd = HAdd.hAdd | true |
QuaternionAlgebra.instAddCommGroupWithOne._proof_3 | Mathlib.Algebra.Quaternion | ∀ {R : Type u_1} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑(Int.negSucc n) = -↑(n + 1) | false |
_private.Mathlib.Topology.Algebra.Valued.LocallyCompact.0.Valued.integer.totallyBounded_iff_finite_residueField._simp_1_7 | Mathlib.Topology.Algebra.Valued.LocallyCompact | ∀ {α : Type u} {β : Type v} (f : α → β) (s : Set α) (y : β), (y ∈ f '' s) = ∃ x ∈ s, f x = y | false |
ChartedSpaceCore.chart_mem_atlas | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_5} [inst : TopologicalSpace H] {M : Type u_6} (self : ChartedSpaceCore H M) (x : M),
self.chartAt x ∈ self.atlas | true |
Convex.toCone._simp_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
Submodule.pow_smul_top_le | Mathlib.RingTheory.Ideal.Quotient.PowTransition | ∀ {R : Type u_1} [inst : Ring R] (I : Ideal R) (M : Type u_2) [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m n : ℕ},
m ≤ n → I ^ n • ⊤ ≤ I ^ m • ⊤ | true |
_private.Batteries.Tactic.SqueezeScope.0.Batteries.Tactic._aux_Batteries_Tactic_SqueezeScope___elabRules__private_Batteries_Tactic_SqueezeScope_0_Batteries_Tactic_squeezeWrap_1.match_7 | Batteries.Tactic.SqueezeScope | (motive : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger) → Sort u_1) →
(discharger : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger)) →
((discharger : Lean.TSyntax `Lean.Parser.Tactic.discharger) → motive (some discharger)) →
((x : Option (Lean.TSyntax `Lean.Parser.Tactic.discharger)) → motive x)... | false |
CategoryTheory.ObjectProperty.SerreClassLocalization.whiskeringLeft_obj_obj | Mathlib.CategoryTheory.Abelian.SerreClass.Localization | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] (L : CategoryTheory.Functor C D) (P : CategoryTheory.ObjectProperty C)
[inst_3 : P.IsSerreClass] (E : Type u'') [inst_4 : CategoryTheory.Category.{v'', u''} E]
[... | true |
Complex.commRing._proof_9 | Mathlib.Data.Complex.Basic | ∀ (x : ℂ), npowRec 0 x = 1 | false |
PowerSeries.WithPiTopology.summable_prod_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Summable fun x => ∏ i ∈ x, f i | true |
CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._proof_12 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₂ n₃ : ℤ), autoParam (n₂ + 1 = n₃) CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._auto_5 → n₂ + 1 = n₃ | false |
_private.Init.Data.Array.Erase.0.Array.getElem?_eraseIdx_of_ge._proof_1_2 | Init.Data.Array.Erase | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, i ≤ j → j < i → False | false |
Multiset.attach_map_val' | Mathlib.Data.Multiset.MapFold | ∀ {α : Type u_1} {β : Type v} (s : Multiset α) (f : α → β), Multiset.map (fun i => f ↑i) s.attach = Multiset.map f s | true |
Lean.Meta.mkLE | Lean.Meta.AppBuilder | Lean.Expr → Lean.Expr → Lean.MetaM Lean.Expr | true |
CategoryTheory.LeftExactFunctor.forget_obj | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : C ⥤ₗ D), (CategoryTheory.LeftExactFunctor.forget C D).obj F = F.obj | true |
_private.Mathlib.CategoryTheory.Join.Basic.0.CategoryTheory.Join.comp.match_1.eq_3 | Mathlib.CategoryTheory.Join.Basic | ∀ {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]
(motive : (x x_1 x_2 : CategoryTheory.Join C D) → x.Hom x_1 → x_1.Hom x_2 → Sort u_5) (_x : C) (_y _z : D)
(x : (CategoryTheory.Join.left _x).Hom (CategoryTheory.Join.right _y))
(x_1 : (... | true |
Lean.Lsp.CompletionList.items | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionList → Array Lean.Lsp.CompletionItem | true |
Lean.Lsp.DeleteFile.Options.mk | Lean.Data.Lsp.Basic | Bool → Bool → Lean.Lsp.DeleteFile.Options | true |
Set.graphOn_union | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s t : Set α), Set.graphOn f (s ∪ t) = Set.graphOn f s ∪ Set.graphOn f t | true |
MeasureTheory.SimpleFunc.nearestPtInd._sunfold | Mathlib.MeasureTheory.Function.SimpleFuncDense | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : PseudoEMetricSpace α] → [OpensMeasurableSpace α] → (ℕ → α) → ℕ → MeasureTheory.SimpleFunc α ℕ | false |
CategoryTheory.CostructuredArrow.projectQuotient_factors | Mathlib.CategoryTheory.Subobject.Comma | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{S : CategoryTheory.Functor C D} {T : D} [inst_2 : CategoryTheory.Limits.HasFiniteColimits C]
[inst_3 : CategoryTheory.Limits.PreservesFiniteColimits S] {A : CategoryTheory.CostructuredArrow S T}
... | true |
String.Slice.Pattern.Model.Char.isMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c | true |
Matrix.toLin'OfInv._proof_3 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_3} {n : Type u_2} [inst_1 : Fintype m] [inst_2 : DecidableEq m]
{M' : Matrix n m R} (x y : m → R),
(Matrix.toLin' M').toFun (x + y) = (Matrix.toLin' M').toFun x + (Matrix.toLin' M').toFun y | false |
Relation.TransGen.lift | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {r : α → α → Prop} {p : β → β → Prop} {a b : α} (f : α → β),
(∀ (a b : α), r a b → p (f a) (f b)) → Relation.TransGen r a b → Relation.TransGen p (f a) (f b) | true |
CategoryTheory.Presieve.map_singleton | Mathlib.CategoryTheory.Sites.Sieves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F : CategoryTheory.Functor C D} {X Y : C} (f : X ⟶ Y),
CategoryTheory.Presieve.map F (CategoryTheory.Presieve.singleton f) = CategoryTheory.Presieve.singleton (F.map f) | true |
Int.lt_neg_iff | Init.Data.Int.Order | ∀ {x y : ℤ}, x < -y ↔ y < -x | true |
AbsConvexOpenSets.coe_balanced | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), Balanced 𝕜 ↑s | true |
Function.mulSupport_nonempty_iff._simp_2 | Mathlib.Algebra.Notation.Support | ∀ {ι : Type u_1} {M : Type u_3} [inst : One M] {f : ι → M}, (Function.mulSupport f).Nonempty = (f ≠ 1) | false |
Ordnode.splitMax'._unsafe_rec | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → α → Ordnode α → Ordnode α × α | false |
AlternatingMap.curryLeftLinearMap._proof_1 | Mathlib.LinearAlgebra.Alternating.Curry | ∀ {R : Type u_1} {M : Type u_3} {N : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : Module R M] [inst_4 : Module R N] {n : ℕ}, SMulCommClass R R (M [⋀^Fin n]→ₗ[R] N) | false |
Std.PRange.UpwardEnumerable.Map.PreservesRxoSize.casesOn | Init.Data.Range.Polymorphic.Map | {α : Type u_1} →
{β : Type u_2} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.UpwardEnumerable β] →
[inst_2 : Std.Rxo.HasSize α] →
[inst_3 : Std.Rxo.HasSize β] →
{f : Std.PRange.UpwardEnumerable.Map α β} →
{motive : f.PreservesRxoSize → Sort u} →... | false |
CategoryTheory.Monad.forgetCreatesLimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} → CategoryTheory.CreatesLimitsOfSize.{u_1, u_2, v₁, v₁, max u₁ v₁, u₁} T.forget | true |
_private.Aesop.Forward.Substitution.0.Aesop.Substitution.cmpExprs | Aesop.Forward.Substitution | Lean.Expr → Lean.Expr → Ordering | true |
Lean.Syntax.isAntiquots | Lean.Syntax | Lean.Syntax → Bool | true |
Cardinal.ofENat_le_ofENat | Mathlib.SetTheory.Cardinal.ENat | ∀ {m n : ℕ∞}, ↑m ≤ ↑n ↔ m ≤ n | true |
Lean.Lsp.ClientCapabilities.window?._default | Lean.Data.Lsp.Capabilities | Option Lean.Lsp.WindowClientCapabilities | false |
_private.Mathlib.Geometry.Euclidean.SignedDist.0.Affine.Simplex.signedInfDist_affineCombination._simp_1_4 | Mathlib.Geometry.Euclidean.SignedDist | ∀ {α : Type u_1} {a b : α}, (b ∈ {a}) = (b = a) | false |
HasFPowerSeriesWithinAt.restrictScalars | Mathlib.Analysis.Analytic.Constructions | ∀ {𝕜 : Type u_2} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} {F : Type u_4} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {𝕜' : Type u_9}
[inst_5 : NontriviallyNormedField 𝕜'] [inst_6 : NormedAlgebra 𝕜 𝕜'] [inst_7 : NormedSpace 𝕜... | true |
NFA.evalFrom_iUnion₂ | Mathlib.Computability.NFA | ∀ {α : Type u} {σ : Type v} (M : NFA α σ) {ι : Sort u_1} {κ : ι → Sort u_2} (f : (i : ι) → κ i → Set σ) (x : List α),
M.evalFrom (⋃ i, ⋃ j, f i j) x = ⋃ i, ⋃ j, M.evalFrom (f i j) x | true |
_private.Mathlib.Order.Interval.Finset.Fin.0.Fin.finsetImage_natAdd_Ioc._simp_1_1 | Mathlib.Order.Interval.Finset.Fin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ = s₂) = (↑s₁ = ↑s₂) | false |
SimpleGraph.deleteEdges | Mathlib.Combinatorics.SimpleGraph.DeleteEdges | {V : Type u_1} → SimpleGraph V → Set (Sym2 V) → SimpleGraph V | true |
SheafOfModules.Presentation.map | 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.HasSheafCo... | true |
Nat.max_self | Init.Data.Nat.Lemmas | ∀ (a : ℕ), max a a = a | true |
WithTop.semilatticeSup._proof_2 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : SemilatticeSup α] (x y : WithTop α), y ≤ WithTop.map₂ (fun x1 x2 => x1 ⊔ x2) x y | false |
OpenAddSubgroup.instSetLike.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G],
OpenAddSubgroup.instSetLike = { coe := fun U => ↑↑U, coe_injective' := ⋯ } | true |
PiLp.instEMetricSpace | Mathlib.Analysis.Normed.Lp.PiLp | (p : ENNReal) →
{ι : Type u_2} →
(α : ι → Type u_3) → [hp : Fact (1 ≤ p)] → [Fintype ι] → [(i : ι) → EMetricSpace (α i)] → EMetricSpace (PiLp p α) | true |
Lean.Meta.Simp.Config.catchRuntime | Init.MetaTypes | Lean.Meta.Simp.Config → Bool | true |
CategoryTheory.BimonObj.one_counit | Mathlib.CategoryTheory.Monoidal.Bimon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C}
{inst_2 : CategoryTheory.BraidedCategory C} (M : C) [self : CategoryTheory.BimonObj M],
CategoryTheory.CategoryStruct.comp CategoryTheory.MonObj.one CategoryTheory.ComonObj.counit =
CategoryTheory.CategorySt... | true |
CategoryTheory.PreOneHypercover.Hom.mapMultiforkOfIsLimit_comp_assoc | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} A]
{S : C} {E : CategoryTheory.PreOneHypercover S} {F : CategoryTheory.PreOneHypercover S}
{G : CategoryTheory.PreOneHypercover S} (f : E.Hom F) (P : CategoryTheory.Functor Cᵒᵖ A)
{c : CategoryTheo... | true |
Equiv.piCongrLeft_symm_preimage_pi | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {ι' : Type u_2} {α : ι → Type u_3} (f : ι' ≃ ι) (s : Set ι') (t : (i : ι) → Set (α i)),
(⇑(Equiv.piCongrLeft α f).symm ⁻¹' s.pi fun i' => t (f i')) = (⇑f '' s).pi t | true |
Lean.PersistentEnvExtensionDescr.noConfusion | Lean.Environment | {P : Sort u} →
{α β σ : Type} →
{t : Lean.PersistentEnvExtensionDescr α β σ} →
{α' β' σ' : Type} →
{t' : Lean.PersistentEnvExtensionDescr α' β' σ'} →
α = α' → β = β' → σ = σ' → t ≍ t' → Lean.PersistentEnvExtensionDescr.noConfusionType P t t' | false |
FirstOrder.Language.inhabited_FGEquiv_of_IsEmpty_Constants_and_Relations._proof_3 | Mathlib.ModelTheory.PartialEquiv | ∀ {L : FirstOrder.Language} {M : Type u_1} {N : Type u_4} [inst : L.Structure M] [inst_1 : L.Structure N]
[inst_2 : IsEmpty L.Constants] (a : ↥⊥), isEmptyElim (isEmptyElim a) = a | false |
CategoryTheory.GrothendieckTopology.Point.subsingleton_fiber_obj | Mathlib.CategoryTheory.Sites.Point.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : CategoryTheory.GrothendieckTopology C} (Φ : J.Point)
[CategoryTheory.LocallySmall.{w, v, u} C] {U T : C} (f : U ⟶ T) [CategoryTheory.Mono f]
(hT : CategoryTheory.Limits.IsTerminal T), Subsingleton (Φ.fiber.obj U) | true |
CategoryTheory.FreeMonoidalCategory.unit.elim | Mathlib.CategoryTheory.Monoidal.Free.Basic | {C : Type u} →
{motive : CategoryTheory.FreeMonoidalCategory C → Sort u_1} →
(t : CategoryTheory.FreeMonoidalCategory C) →
t.ctorIdx = 1 → motive CategoryTheory.FreeMonoidalCategory.unit → motive t | false |
FreeAlgebra.Rel.rec | Mathlib.Algebra.FreeAlgebra | ∀ {R : Type u_1} {X : Type u_2} [inst : CommSemiring R]
{motive : (a a_1 : FreeAlgebra.Pre R X) → FreeAlgebra.Rel R X a a_1 → Prop},
(∀ {r s : R}, motive (FreeAlgebra.Pre.ofScalar (r + s)) (FreeAlgebra.Pre.ofScalar r + FreeAlgebra.Pre.ofScalar s) ⋯) →
(∀ {r s : R},
motive (FreeAlgebra.Pre.ofScalar (r * ... | false |
AddSubgroupClass.normedAddGroup._proof_2 | Mathlib.Analysis.Normed.Group.Subgroup | ∀ {E : Type u_1} {S : Type u_2} [inst : SetLike S E] (s : S), Function.Injective fun a => ↑a | false |
CategoryTheory.Over.ConstructProducts.conesEquivCounitIso | Mathlib.CategoryTheory.Limits.Constructions.Over.Products | {J : Type w} →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(B : C) →
(F : CategoryTheory.Functor (CategoryTheory.Discrete J) (CategoryTheory.Over B)) →
(CategoryTheory.Over.ConstructProducts.conesEquivInverse B F).comp
(CategoryTheory.Over.ConstructProducts.con... | true |
Module.rankAtStalk | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | {R : Type uR} → (M : Type uM) → [inst : CommRing R] → [inst_1 : AddCommGroup M] → [Module R M] → PrimeSpectrum R → ℕ | true |
Algebra.IsPushout.cancelBaseChange_symm_comp_lTensor | Mathlib.RingTheory.IsTensorProduct | ∀ (R : Type u_1) [inst : CommSemiring R] (A : Type u_8) [inst_1 : CommRing A] [inst_2 : Algebra R A] (C : Type u_11)
[inst_3 : CommRing C] [inst_4 : Algebra R C] [inst_5 : Algebra A C] [inst_6 : IsScalarTower R A C] (S : Type u_12)
[inst_7 : CommRing S] [inst_8 : Algebra R S],
(↑(Algebra.IsPushout.cancelBaseChang... | true |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.IsNat.to_eq.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : AddMonoidWithOne α] {n : ℕ}
(motive : (x x_1 : α) → Mathlib.Meta.NormNum.IsNat x n → ↑n = x_1 → Prop) (x x_1 : α)
(x_2 : Mathlib.Meta.NormNum.IsNat x n) (x_3 : ↑n = x_1), (∀ (a : Unit), motive ↑n ↑n ⋯ ⋯) → motive x x_1 x_2 x_3 | false |
Std.Tactic.BVDecide.LRAT.Internal.Result.outOfProof.elim | Std.Tactic.BVDecide.LRAT.Internal.LRATChecker | {motive : Std.Tactic.BVDecide.LRAT.Internal.Result → Sort u} →
(t : Std.Tactic.BVDecide.LRAT.Internal.Result) →
t.ctorIdx = 1 → motive Std.Tactic.BVDecide.LRAT.Internal.Result.outOfProof → motive t | false |
Finset.mem_ssubsets._simp_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Finset α}, (t ∈ s.ssubsets) = (t ⊂ s) | false |
Sum.elim_zero_single | Mathlib.Algebra.Group.Pi.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq β] [inst_2 : Zero γ] (i : β)
(c : γ), Sum.elim 0 (Pi.single i c) = Pi.single (Sum.inr i) c | true |
Std.Internal.List.maxKey!_eq_default | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
[inst_4 : Inhabited α] {l : List ((a : α) × β a)}, l.isEmpty = true → Std.Internal.List.maxKey! l = default | true |
AddOreLocalization.AddOreSet.oreSubtra | Mathlib.GroupTheory.OreLocalization.OreSet | {R : Type u_1} → {inst : AddMonoid R} → {S : AddSubmonoid R} → [self : AddOreLocalization.AddOreSet S] → R → ↥S → ↥S | true |
Lean.Elab.Term.Do.ToTerm.mkIte | Lean.Elab.Do.Legacy | Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.Syntax → Lean.MacroM Lean.Syntax | true |
_private.Mathlib.Algebra.Homology.SpectralObject.Homology.0.CategoryTheory.Abelian.SpectralObject.dKernelSequence_exact._proof_1_4 | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ (n₀ n₁ n₂ n₃ : ℤ), 0 < 3 + 1 | false |
CategoryTheory.hom_inv_id_apply | Mathlib.CategoryTheory.Types.Basic | ∀ {X Y : Type u} (f : X ≅ Y) (x : X), f.inv (f.hom x) = x | true |
Sylow.mulEquivIteratedWreathProduct._proof_4 | Mathlib.GroupTheory.RegularWreathProduct | ∀ (p n : ℕ) (α : Type u_2) [inst : Finite α] (hα : Nat.card α = p ^ n) (G : Type u_1) [inst_1 : Group G]
[inst_2 : Finite G] (hG : Nat.card G = p),
Function.Injective
(⇑((Finite.equivFinOfCardEq hα).trans (Finite.equivFinOfCardEq ⋯).symm).symm.permCongrHom.toEquiv ∘
⇑(iteratedWreathToPermHom G n)) | false |
sSup_eq_bot' | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} [inst : CompleteLattice α] {s : Set α}, sSup s = ⊥ ↔ s = ∅ ∨ s = {⊥} | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.