name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.ObjectProperty.trW_iff' | Mathlib.CategoryTheory.Triangulated.Subcategory | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} 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]
(P : CategoryT... | null | true |
LipschitzWith.lipschitzOnWith | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
{s : Set α}, LipschitzWith K f → LipschitzOnWith K f s | null | true |
Multiset.countP_le_of_le | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Multiset α},
s ≤ t → Multiset.countP p s ≤ Multiset.countP p t | null | true |
CategoryTheory.Functor.OplaxMonoidal.id._proof_2 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X X')))
... | null | false |
iSup_eq_bot | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥ | null | true |
_private.Mathlib.SetTheory.Ordinal.CantorNormalForm.0.Ordinal.CNF.rec._proof_2 | Mathlib.SetTheory.Ordinal.CantorNormalForm | ∀ (o : Ordinal.{u_1}), o = 0 → 0 = o | null | false |
Relation.reflTransGen_of_equivalence | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a b : α} {r' : α → α → Prop},
Equivalence r → (∀ (a b : α), r' a b → r a b) → Relation.ReflTransGen r' a b → r a b | null | true |
List.dropLast_eq_eraseIdx | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i + 1 = xs.length → xs.dropLast = xs.eraseIdx i | null | true |
Lean.Meta.Grind.instInhabitedAction | Lean.Meta.Tactic.Grind.Types | Inhabited Lean.Meta.Grind.Action | null | true |
_private.Init.Data.String.Lemmas.Pattern.TakeDrop.Basic.0.String.Slice.Pattern.Model.skipPrefixWhile_eq_iff._simp_1_1 | Init.Data.String.Lemmas.Pattern.TakeDrop.Basic | ∀ {ρ : Type} (pat : ρ) [inst : String.Slice.Pattern.Model.PatternModel pat]
[inst_1 : String.Slice.Pattern.ForwardPattern pat] [String.Slice.Pattern.Model.LawfulForwardPatternModel pat]
{s : String.Slice} (startPos endPos : s.Pos),
(startPos.skipWhile pat = endPos) =
(String.Slice.Pattern.Model.IsLongestMatch... | null | false |
Lean.Parser.CacheableParserContext.noConfusion | Lean.Parser.Types | {P : Sort u} →
{t t' : Lean.Parser.CacheableParserContext} → t = t' → Lean.Parser.CacheableParserContext.noConfusionType P t t' | null | false |
_private.Mathlib.Algebra.Polynomial.RingDivision.0.Polynomial.prime_X_sub_C._simp_1_2 | Mathlib.Algebra.Polynomial.RingDivision | ∀ {R : Type u} {a : R} [inst : Semiring R] {p : Polynomial R}, p.IsRoot a = (Polynomial.eval a p = 0) | null | false |
List.findSomeRev?.eq_def | Init.Data.List.Impl | ∀ {α : Type u} {β : Type v} (f : α → Option β) (x : List α),
List.findSomeRev? f x =
match x with
| [] => none
| a :: as =>
match List.findSomeRev? f as with
| some b => some b
| none => f a | null | true |
_private.Lean.Environment.0.Lean.AsyncConsts.normalizedTrie | Lean.Environment | Lean.AsyncConsts✝ → Lean.NameTrie Lean.AsyncConst✝ | Trie of declaration names without private name prefixes for fast longest-prefix access. | true |
_private.Mathlib.Logic.Embedding.Set.0.Function.Embedding.sigmaSet_preimage._simp_1_1 | Mathlib.Logic.Embedding.Set | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
Topology.CWComplex.Subcomplex.coe_mk'' | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {X : Type u_1} [t : TopologicalSpace X] [inst : T2Space X] (C : Set X) [h : Topology.CWComplex C] (E : Set X)
(I : (n : ℕ) → Set (Topology.RelCWComplex.cell C n)) [inst_1 : Topology.CWComplex E]
(union : ⋃ n, ⋃ j, Topology.RelCWComplex.openCell n ↑j = E), ↑(Topology.CWComplex.Subcomplex.mk'' C E I union) = E | null | true |
_private.Mathlib.Analysis.Convex.Combination.0.AffineIndependent.convexHull_inter._simp_1_4 | Mathlib.Analysis.Convex.Combination | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (p : ι → Prop) [inst_1 : DecidablePred p]
(f : ι → M), (∑ a ∈ s, if p a then f a else 0) = ∑ a ∈ s with p a, f a | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal.0.AugmentedSimplexCategory.tensorObj.match_1.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Monoidal | ∀ (motive : AugmentedSimplexCategory → AugmentedSimplexCategory → Sort u_1) (m n : SimplexCategory)
(h_1 : (m n : SimplexCategory) → motive (CategoryTheory.WithInitial.of m) (CategoryTheory.WithInitial.of n))
(h_2 : (x : AugmentedSimplexCategory) → motive CategoryTheory.WithInitial.star x)
(h_3 : (x : AugmentedSi... | null | true |
Int.mul_fmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod b = 0 | null | true |
Lean.StructureResolutionState.casesOn | Lean.Structure | {motive : Lean.StructureResolutionState → Sort u} →
(t : Lean.StructureResolutionState) →
((resolutions : Lean.PHashMap Lean.Name (Array Lean.Name)) → motive { resolutions := resolutions }) → motive t | null | false |
WeierstrassCurve.variableChange_j | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R)
[inst_1 : W.IsElliptic], (C • W).j = W.j | null | true |
Lean.Options.ctorIdx | Lean.Data.Options | Lean.Options → ℕ | null | false |
Cardinal.lift_max | Mathlib.SetTheory.Cardinal.Order | ∀ {a b : Cardinal.{v}}, Cardinal.lift.{u, v} (max a b) = max (Cardinal.lift.{u, v} a) (Cardinal.lift.{u, v} b) | null | true |
CategoryTheory.presheafHom | Mathlib.CategoryTheory.Sites.SheafHom | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : Type u'} →
[inst_1 : CategoryTheory.Category.{v', u'} A] →
CategoryTheory.Functor Cᵒᵖ A →
CategoryTheory.Functor Cᵒᵖ A → CategoryTheory.Functor Cᵒᵖ (Type (max (max u v) v')) | Given two presheaves `F` and `G` on a category `C` with values in a category `A`,
this `presheafHom F G` is the presheaf of types which sends an object `X : C`
to the type of morphisms between the "restrictions" of `F` and `G` to the category `Over X`. | true |
QuaternionAlgebra.im_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), (↑n).im = 0 | null | true |
PNat.instMetricSpace._proof_16 | Mathlib.Topology.Instances.PNat | Filter.Tendsto Prod.swap PNat.instMetricSpace._aux_14 PNat.instMetricSpace._aux_14 | null | false |
CategoryTheory.ShortComplex.cyclesMapIso'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' e.inv h₂ h₁)
... | null | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalWhiskerRightAux.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.HorizontalComp → Mathlib.Tactic.BicategoryLike.Atom₁ → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.HorizontalComp) →
(x_1 : Mathlib.Tactic.BicategoryLike.Atom₁) →
((η : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁... | null | false |
Array.filter_replicate_of_neg | Init.Data.Array.Lemmas | ∀ {stop n : ℕ} {α : Type u_1} {p : α → Bool} {a : α},
stop = n → ¬p a = true → Array.filter p (Array.replicate n a) 0 stop = #[] | null | true |
LieEquiv.invFun | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{L' : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → [inst_3 : LieRing L'] → [inst_4 : LieAlgebra R L'] → (L ≃ₗ⁅R⁆ L') → L' → L | The inverse function of an equivalence of Lie algebras | true |
UniformContinuous.sup_compacts | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β]
{f g : α → TopologicalSpace.Compacts β},
UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x ⊔ g x | null | true |
Mathlib.Tactic.FinVec.vecPerm | Mathlib.Tactic.Simproc.VecPerm | Lean.Meta.Simp.Simproc | The `vecPerm` simproc computes the new entries of a vector after applying a permutation to them.
This can be used to simplify expressions as follows:
```
example {a b c : Nat} : ![a, b, c] ∘ Equiv.swap 0 1 = ![b, a, c] := by
simp [vecPerm, Equiv.swap_apply_def]
```
Note that for this simproc to work, dsimp needs to b... | true |
subset_of_subset_of_eq | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] {a b c : α}, a ⊆ b → b = c → a ⊆ c | null | true |
Matroid.IsLoop.dep_of_mem._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | null | false |
toIcoDiv_add_intCast_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoDiv hp a (b + ↑m * p) = toIcoDiv hp a b + m | null | true |
Set.biInter_subset_biUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s.Nonempty → ∀ {t : α → Set β}, ⋂ x ∈ s, t x ⊆ ⋃ x ∈ s, t x | null | true |
_private.Lean.Meta.Tactic.FunInd.0.Lean.Tactic.FunInd.foldAndCollect._sparseCasesOn_16 | Lean.Meta.Tactic.FunInd | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
AbstractCompletion.mapEquiv._proof_3 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_3} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_1, u_3} α) {β : Type u_4}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_2, u_4} β) (e : α ≃ᵤ β),
Function.LeftInverse (pkg'.map pkg ⇑e.symm) (pkg.map pkg' ⇑e) | null | false |
SymAlg.addMonoid._proof_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : AddMonoid α], SymAlg.unsym 0 = 0 | null | false |
CategoryTheory.Coyoneda.colimitCocone_pt | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ),
(CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1} | null | true |
ModularForm.eisensteinSeriesMF._proof_2 | Mathlib.NumberTheory.ModularForms.EisensteinSeries.Basic | ∀ {k : ℤ} {N : ℕ} (a : Fin 2 → ZMod N),
∀ γ ∈ Subgroup.map (Matrix.SpecialLinearGroup.mapGL ℝ) (CongruenceSubgroup.Gamma N),
SlashAction.map k γ (EisensteinSeries.eisensteinSeriesSIF a k).toFun =
(EisensteinSeries.eisensteinSeriesSIF a k).toFun | null | false |
SetLike.instSubtypeSet._proof_1 | Mathlib.Data.SetLike.Basic | ∀ {X : Type u_1} {p : Set X → Prop}, Function.Injective Subtype.val | null | false |
Lean.Order.Array.monotone_allM | Init.Internal.Order.Lemmas | ∀ {γ : Type w} [inst : Lean.Order.PartialOrder γ] {m : Type → Type v} [inst_1 : Monad m]
[inst_2 : (α : Type) → Lean.Order.PartialOrder (m α)] [Lean.Order.MonoBind m] {α : Type u} (f : γ → α → m Bool)
(xs : Array α) (start stop : ℕ), Lean.Order.monotone f → Lean.Order.monotone fun x => Array.allM (f x) xs start sto... | null | true |
DirectSum.instCommSemiringOfNat._proof_7 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommMonoid (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommSemiring A] (x : A 0) (x_1 : ℕ),
(DirectSum.of A 0) (x ^ x_1) = (DirectSum.of A 0) x ^ x_1 | null | false |
SimpleGraph.CompleteEquipartiteSubgraph.ofCopy | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | {V : Type u_1} →
{G : SimpleGraph V} →
{r t : ℕ} → (SimpleGraph.completeEquipartiteGraph r t).Copy G → G.CompleteEquipartiteSubgraph r t | A copy of a complete equipartite graph identifies a complete equipartite subgraph. | true |
_private.Mathlib.Topology.Algebra.InfiniteSum.Order.0.Mathlib.Meta.Positivity.evalTsum._proof_1 | Mathlib.Topology.Algebra.InfiniteSum.Order | ∀ {u : Lean.Level} {α : Q(Type u)} (zα : Q(Zero «$α»)) (mα' : Q(AddCommMonoid «$α»))
(__defeqres : PLift («$zα» =Q «$mα'».toAddZeroClass.toZero)), «$zα» =Q «$mα'».toAddZeroClass.toZero | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNeg | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (value : BitVec w)
(target : aig.RefVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := target.get idx hidx }⟧ = value.getLsbD idx) →
∀ (idx : ℕ) (hidx : idx < w),
⟦assign,
... | null | true |
Int8.neg_neg | Init.Data.SInt.Lemmas | ∀ {a : Int8}, - -a = a | null | true |
_private.Mathlib.Util.CompileInductive.0.Float.mk_eq | Mathlib.Util.CompileInductive | Float.mk = Float.mkImpl✝ | null | true |
Std.Do.Spec.forIn'_rii._proof_3 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α] [inst_3 : Std.PRange.LawfulUpwardEnumerable α] {xs : Std.Rii α} (pref : List α)
(cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → pref ++ [cur] ++ suff = xs.toList | null | false |
MulEquiv.toMagmaCatIso | Mathlib.Algebra.Category.Semigrp.Basic | {X Y : Type u} → [inst : Mul X] → [inst_1 : Mul Y] → X ≃* Y → (MagmaCat.of X ≅ MagmaCat.of Y) | Build an isomorphism in the category `MagmaCat` from a `MulEquiv` between `Mul`s. | true |
_private.Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup.0.Matrix.commutator_diag2_transvection._simp_1_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {M : Type u_2} [inst : Monoid M] (a : M), a * a = a ^ 2 | null | false |
ProbabilityTheory.binomial_nat | Mathlib.Probability.Distributions.Binomial | ∀ {n : ℕ} {p : ↑unitInterval},
MeasureTheory.Measure.map Nat.cast (ProbabilityTheory.binomial n p) = ProbabilityTheory.binomial n p | null | true |
_private.Mathlib.FieldTheory.Normal.Closure.0.isNormalClosure_normalClosure.match_1 | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_3) (K : Type u_2) (L : Type u_1) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (ne : Nonempty (K →ₐ[F] L)),
(∀ (φ : K →ₐ[F] L), motive ⋯) → motive ne | null | false |
Turing.PartrecToTM2.Λ'.rec | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Λ' → Sort u} →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.move p k₁ k₂ q)) →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k : Turing.PartrecToTM2.K') →
(... | null | false |
WithZero.le_log_of_exp_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {G : Type u_3} [inst : Preorder G] {a : G} [inst_1 : AddGroup G] {x : WithZero (Multiplicative G)},
WithZero.exp a ≤ x → a ≤ x.log | null | true |
compl_ne_self._simp_1 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] {a : α} [Nontrivial α], (aᶜ = a) = False | null | false |
ValuativeRel.ValueGroupWithZero.lift_valuation | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : ValuativeRel R] {α : Sort u_3} (f : R → ↥(ValuativeRel.posSubmonoid R) → α)
(hf : ∀ (x y : R) (t s : ↥(ValuativeRel.posSubmonoid R)), x * ↑t ≤ᵥ y * ↑s → y * ↑s ≤ᵥ x * ↑t → f x s = f y t)
(x : R), ValuativeRel.ValueGroupWithZero.lift f hf ((ValuativeRel.valuation R) x) = f ... | null | true |
RingEquiv.toRingCatIso._proof_2 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Ring R] [inst_1 : Ring S] (e : R ≃+* S),
CategoryTheory.CategoryStruct.comp (RingCat.ofHom ↑e) (RingCat.ofHom ↑e.symm) =
CategoryTheory.CategoryStruct.id (RingCat.of R) | null | false |
String.Slice.endsWith_string_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String} {s : String.Slice}, s.endsWith pat = true ↔ pat.toList <:+ s.copy.toList | null | true |
Unitization.inl_zero | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_3} (A : Type u_4) [inst : Zero R] [inst_1 : Zero A], Unitization.inl 0 = 0 | null | true |
Rep.FiniteCyclicGroup.groupHomologyIsoOdd._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G)
(g : G), (Rep.FiniteCyclicGroup.normHomCompSub A g).HasHomology | null | false |
Std.IterStep.mapIterator | Init.Data.Iterators.Basic | {α : Type u} → {β : Type w} → {α' : Type u'} → (α → α') → Std.IterStep α β → Std.IterStep α' β | If present, applies `f` to the iterator of an `IterStep` and replaces the iterator
with the result of the application of `f`.
| true |
List.takeWhile_append_dropWhile | Init.Data.List.TakeDrop | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.takeWhile p l ++ List.dropWhile p l = l | null | true |
CategoryTheory.WideSubcategory | Mathlib.CategoryTheory.Widesubcategory | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(_P : CategoryTheory.MorphismProperty C) → [_P.IsMultiplicative] → Type u₁ | Structure for wide subcategories. Objects ignore the morphism property.
| true |
_private.Batteries.Data.MLList.Basic.0.MLList.uncons?Impl.match_1 | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} →
{α : Type u_1} →
(motive : MLList.MLListImpl✝ m α → Sort u_2) →
(x : MLList.MLListImpl✝ m α) →
(Unit → motive MLList.MLListImpl.nil✝) →
((x : α) → (xs : MLList.MLListImpl✝ m α) → motive (MLList.MLListImpl.cons✝ x xs)) →
((x : MLList.MLListImpl✝ m α) ... | null | false |
Lean.Meta.Grind.ppPattern | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Expr → Lean.MessageData | null | true |
EReal.neTopBotEquivReal._proof_7 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (fun x => (↑x).toReal) ((fun x => ⟨↑x, ⋯⟩) x) = x | null | false |
ArchimedeanClass.FiniteResidueField.instLinearOrder._aux_1 | Mathlib.Algebra.Order.Ring.StandardPart | {K : Type u_1} →
[inst : LinearOrder K] →
[inst_1 : Field K] →
[inst_2 : IsOrderedRing K] → ArchimedeanClass.FiniteResidueField K → ArchimedeanClass.FiniteResidueField K → Prop | null | false |
LinearMap.tensorKerBil._proof_6 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | null | false |
Monoid.PushoutI.NormalWord.rcons.eq_1 | Mathlib.GroupTheory.PushoutI | ∀ {ι : Type u_1} {G : ι → Type u_2} {H : Type u_3} [inst : (i : ι) → Group (G i)] [inst_1 : Group H]
{φ : (i : ι) → H →* G i} {d : Monoid.PushoutI.NormalWord.Transversal φ} [inst_2 : DecidableEq ι]
[inst_3 : (i : ι) → DecidableEq (G i)] (i : ι) (p : Monoid.PushoutI.NormalWord.Pair d i),
Monoid.PushoutI.NormalWord... | null | true |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe | Mathlib.Tactic.FBinop | FBinopElab.Tree✝ → FBinopElab.SRec → Lean.Elab.TermElabM FBinopElab.Tree✝ | Try to coerce elements in the tree to `maxS` when needed. | true |
max_le_max_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b : α} (c : α), a ≤ b → max c a ≤ max c b | null | true |
Submonoid.prod_mem | Mathlib.Algebra.Group.Submonoid.BigOperators | ∀ {M : Type u_4} [inst : CommMonoid M] (S : Submonoid M) {ι : Type u_5} {t : Finset ι} {f : ι → M},
(∀ c ∈ t, f c ∈ S) → ∏ c ∈ t, f c ∈ S | Product of elements of a submonoid of a `CommMonoid` indexed by a `Finset` is in the
submonoid. | true |
Matrix.PosSemidef.diagonal | Mathlib.LinearAlgebra.Matrix.PosDef | ∀ {n : Type u_2} {R : Type u_3} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : StarRing R] [StarOrderedRing R]
[inst_4 : DecidableEq n] {d : n → R}, 0 ≤ d → (Matrix.diagonal d).PosSemidef | null | true |
List.map_reverse | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {l : List α}, List.map f l.reverse = (List.map f l).reverse | null | true |
Mathlib.Meta.FunProp.FunctionData.casesOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.FunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionData) →
((lctx : Lean.LocalContext) →
(insts : Lean.LocalInstances) →
(fn : Lean.Expr) →
(args : Array Mathlib.Meta.FunProp.Mor.Arg) →
(mainVar : Lean.Expr) →
(main... | null | false |
_private.Std.Data.DTreeMap.Internal.Balancing.0.Std.DTreeMap.Internal.Impl.Balanced.map.match_1_1 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} {t₁ : Std.DTreeMap.Internal.Impl α β}
(motive : (t₂ : Std.DTreeMap.Internal.Impl α β) → t₁.Balanced → t₁ = t₂ → Prop) (t₂ : Std.DTreeMap.Internal.Impl α β)
(x : t₁.Balanced) (x_1 : t₁ = t₂), (∀ (h : t₁.Balanced), motive t₁ h ⋯) → motive t₂ x x_1 | null | false |
FourierSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransform E F],
(∀ (r : R) (f : E), FourierTransform.fourier (r • f) = r • FourierTransform.fourier f) → FourierSMul R E F | null | false |
Subfield.relfinrank_map_map | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {L : Type w} [inst_1 : Field L] (A B : Subfield E) (f : E →+* L),
(Subfield.map f A).relfinrank (Subfield.map f B) = A.relfinrank B | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Finite.0.AlgebraicGeometry.IsFinite.instHasAffinePropertyAndIsAffineFiniteCarrierObjOppositeOpensCarrierCarrierCommRingCatPresheafOpOpensTopHomAppTop._simp_1 | Mathlib.AlgebraicGeometry.Morphisms.Finite | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y),
AlgebraicGeometry.IsFinite f =
(AlgebraicGeometry.IsAffineHom f ∧
∀ (U : Y.Opens),
AlgebraicGeometry.IsAffineOpen U → (CommRingCat.Hom.hom (AlgebraicGeometry.Scheme.Hom.app f U)).Finite) | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental | Lean.Elab.Tactic.Induction | Lean.Meta.ElimInfo →
Array Lean.Elab.Tactic.ElimApp.Alt →
Lean.Syntax →
Option (Array Lean.Syntax) →
Lean.Syntax →
ℕ →
Array Lean.FVarId →
Array Lean.FVarId →
Array (Lean.Ident × Lean.FVarId) →
Array (Lean.Language.SnapshotBundle ... | null | true |
TopologicalSpace.Opens.coe_disjoint | Mathlib.Topology.Sets.Opens | ∀ {α : Type u_2} [inst : TopologicalSpace α] {s t : TopologicalSpace.Opens α}, Disjoint ↑s ↑t ↔ Disjoint s t | null | true |
antitone_const | Mathlib.Order.Monotone.Defs | ∀ {α : Type u} {β : Type v} [inst : Preorder α] [inst_1 : Preorder β] {c : β}, Antitone fun x => c | null | true |
SkewMonoidAlgebra.addHom_ext_iff | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {M : Type u_3} [inst_1 : AddZeroClass M]
{f g : SkewMonoidAlgebra k G →+ M},
f = g ↔ ∀ (a : G) (b : k), f (SkewMonoidAlgebra.single a b) = g (SkewMonoidAlgebra.single a b) | null | true |
Nat.choose._f | Mathlib.Data.Nat.Choose.Basic | (x : ℕ) → Nat.below (motive := fun x => ℕ → ℕ) x → ℕ → ℕ | null | false |
Polynomial.fiberEquivQuotient._proof_5 | Mathlib.RingTheory.LocalRing.ResidueField.Polynomial | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(f : Polynomial R →ₐ[R] S) (p : Ideal R) [inst_3 : p.IsPrime],
RingHom.ker ↑f ≤ RingHom.ker (Algebra.TensorProduct.includeRight.comp f) | null | false |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) (decVar : Lean.FVarId) (h : Lean.Meta.Grind.Arith.Cutsat.UnsatProof)
(decVars : Array Lean.FVarId),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit c₁ decVar h decVars) =
1 + sizeOf c₁ + sizeOf decVar + sizeOf h + sizeOf decVars | null | true |
Std.Internal.List.getValueCast_modifyKey._proof_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.containsKey k' (Std.Internal.List.modifyKey k f l) = true →
Std.Internal.List.containsKey k' l = true | null | false |
Lean.Meta.Grind.Arith.CommRing.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.State → Lean.Meta.Grind.Arith.CommRing.State → Sort u | null | false |
Finset.prod_flip | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {M : Type u_4} [inst : CommMonoid M] {n : ℕ} (f : ℕ → M),
∏ r ∈ Finset.range (n + 1), f (n - r) = ∏ k ∈ Finset.range (n + 1), f k | null | true |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.measurable_stoppedValue._simp_1_7 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.Nat.isSemilinearSet_of_isSlice._proof_1_5 | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | ∀ {ι : Type u_1} (t : Finset ι) {s : Set (ι → ℕ)} (a : ι → ℕ),
(∀ x ∈ s, ∀ i ∉ t, x i = a i) →
∀ x ∈ s,
∀ (y : ι → ℕ),
y ∈ s ↔ (y ∈ s ∧ ∀ (i : ι), x i ≤ y i) ∨ ∃ i, ∃ (_ : i ∈ t), ∃ i_1, ∃ (_ : i_1 < x i), y ∈ s ∧ y i = i_1 | null | false |
CategoryTheory.Functor.shiftMap.eq_1 | Mathlib.CategoryTheory.Shift.ShiftSequence | ∀ {C : Type u_1} {A : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} A] (F : CategoryTheory.Functor C A) {M : Type u_3} [inst_2 : AddMonoid M]
[inst_3 : CategoryTheory.HasShift C M] [inst_4 : F.ShiftSequence M] {X Y : C} {n : M}
(f : X ⟶ (CategoryTheory.shiftF... | null | true |
DirectSum.GSemiring.natCast_succ | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} {A : ι → Type u_2} {inst : AddMonoid ι} {inst_1 : (i : ι) → AddCommMonoid (A i)}
[self : DirectSum.GSemiring A] (n : ℕ),
DirectSum.GSemiring.natCast (n + 1) = DirectSum.GSemiring.natCast n + GradedMonoid.GOne.one | The canonical map from ℕ to a graded semiring respects successors. | true |
ZMod.val.match_1 | Mathlib.Data.ZMod.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Finset.mul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], Finset.mul = { mul := Finset.image₂ fun x1 x2 => x1 * x2 } | null | true |
NonemptyInterval.subtractionCommMonoid._proof_10 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α],
CovariantClass α α (Function.swap fun x1 x2 => x1 + x2) fun x1 x2 => x1 ≤ x2 | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.precomposeObjTransformObjSquare_iso_hom_app_fst_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
_private.Init.Data.Option.Lemmas.0.Option.merge.match_1.eq_4 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : Option α → Option α → Sort u_2) (x y : α) (h_1 : Unit → motive none none)
(h_2 : (x : α) → motive (some x) none) (h_3 : (y : α) → motive none (some y))
(h_4 : (x y : α) → motive (some x) (some y)),
(match some x, some y with
| none, none => h_1 ()
| some x, none => h_2 x
| n... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.