name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Sheaf.ΓNatIsoLim | 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] →
[inst_3 : CategoryTheory.Limits.HasLimitsOfShape Cᵒᵖ A] →
... | Global sections of sheaves are naturally isomorphic to the limits of the underlying presheaves.
Note that while `HasLimitsOfShape Cᵒᵖ A` is needed here to talk about `lim` as a functor, global
sections are still limits without it - see `Sheaf.isLimitConeΓ`. | true |
ISize.add_assoc | Init.Data.SInt.Lemmas | ∀ (a b c : ISize), a + b + c = a + (b + c) | null | true |
_private.Mathlib.Data.Prod.Lex.0.Prod.Lex.toLex_lt_toLex'._simp_1_2 | Mathlib.Data.Prod.Lex | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, (a = b) = (a ≤ b ∧ b ≤ a) | null | false |
TensorProduct.rightComm._proof_16 | Mathlib.LinearAlgebra.TensorProduct.Associator | ∀ (R : Type u_1) [inst : CommSemiring R] (M : Type u_2) (N : Type u_3) (P : Type u_4) [inst_1 : AddCommMonoid M]
[inst_2 : AddCommMonoid N] [inst_3 : AddCommMonoid P] [inst_4 : Module R M] [inst_5 : Module R N]
[inst_6 : Module R P], SMulCommClass R R (TensorProduct R (TensorProduct R M N) P) | null | false |
MulOpposite.instAddGroupWithOne._proof_5 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : AddGroupWithOne R] (n : ℕ) (a : Rᵐᵒᵖ),
SubNegMonoid.zsmul (↑n.succ) a = SubNegMonoid.zsmul (↑n) a + a | null | false |
Std.DTreeMap.Internal.Impl.Const.minKey?_modify_eq_minKey? | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[Std.LawfulEqOrd α], t.WF → ∀ {k : α} {f : β → β}, (Std.DTreeMap.Internal.Impl.Const.modify k f t).minKey? = t.minKey? | null | true |
PolynomialModule.eval_smul | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Polynomial R)
(q : PolynomialModule R M) (r : R),
(PolynomialModule.eval r) (p • q) = Polynomial.eval r p • (PolynomialModule.eval r) q | null | true |
_private.Std.Sync.Barrier.0.Std.BarrierState.mk._flat_ctor | Std.Sync.Barrier | ℕ → ℕ → Std.BarrierState✝ | null | false |
Std.Time.TimeZone.TZif.instInhabitedTZif | Std.Time.Zoned.Database.TzIf | Inhabited Std.Time.TimeZone.TZif.TZif | null | true |
_private.Lean.Elab.PreDefinition.Basic.0.Lean.Elab.getLevelParamsPreDecls | Lean.Elab.PreDefinition.Basic | Array Lean.Elab.PreDefinition → List Lean.Name → List Lean.Name → Lean.Elab.TermElabM (List Lean.Name) | Collects all the level parameters in sorted order from the types and values of each predefinition.
Throws an "unused universe parameter" error if there is an unused `.{...}` parameter.
See `Lean.collectLevelParams`.
| true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.lintFile.match_3 | Mathlib.Tactic.Linter.TextBased | (motive : Option (Array String) → Sort u_1) →
(changes : Option (Array String)) →
((c : Array String) → motive (some c)) → ((x : Option (Array String)) → motive x) → motive changes | null | false |
_private.Mathlib.FieldTheory.RatFunc.Luroth.0.RatFunc.Luroth.θ_natDegree_le | Mathlib.FieldTheory.RatFunc.Luroth | ∀ {K : Type u_1} [inst : Field K] {E : IntermediateField K (RatFunc K)},
E ≠ ⊥ → (RatFunc.Luroth.θ✝ E).natDegree ≤ RatFunc.Luroth.m✝ E | null | true |
_private.LeanSearchClient.Syntax.0.LeanSearchClient.checkTactic.match_1 | LeanSearchClient.Syntax | (motive : List Lean.MVarId × Lean.Elab.Term.State → Sort u_1) →
(__discr : List Lean.MVarId × Lean.Elab.Term.State) →
((goals : List Lean.MVarId) → (snd : Lean.Elab.Term.State) → motive (goals, snd)) → motive __discr | null | false |
cfcₙ_tsub._auto_9 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | null | false |
Nat.pos_of_neZero | Init.Data.Nat.Basic | ∀ (n : ℕ) [NeZero n], 0 < n | null | true |
CommRingCat.Colimits.Relation.below.mul_zero | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
{motive : (a a_1 : CommRingCat.Colimits.Prequotient F) → CommRingCat.Colimits.Relation F a a_1 → Prop}
(x : CommRingCat.Colimits.Prequotient F), CommRingCat.Colimits.Relation.below ⋯ | null | true |
Lean.Compiler.LCNF.isClass? | Lean.Compiler.LCNF.Types | Lean.Expr → Lean.CoreM (Option Lean.Name) | `isClass? type` return `some ClsName` if the LCNF `type` is an instance of the class `ClsName`.
| true |
AlgCat.adj._proof_4 | Mathlib.Algebra.Category.AlgCat.Basic | ∀ (R : Type u_1) [inst : CommRing R] (x : Type u_1) (x_1 : AlgCat R)
(f : x ⟶ (CategoryTheory.forget (AlgCat R)).obj x_1),
(fun f => TypeCat.ofHom ((FreeAlgebra.lift R).symm (AlgCat.Hom.hom f)))
((fun f => AlgCat.ofHom ((FreeAlgebra.lift R) ⇑(CategoryTheory.ConcreteCategory.hom f))) f) =
f | null | false |
contDiff_const_smul | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type uF} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {n : WithTop ℕ∞} {R : Type u_3} [inst_3 : DistribSMul R F] [SMulCommClass 𝕜 R F]
[ContinuousConstSMul R F] (c : R), ContDiff 𝕜 n fun p => c • p | Scalar multiplication is smooth (as a function of the vector variable). | true |
ContinuousMap.Homotopy.trans._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], Continuous fun x => ↑x.1 | null | false |
Lean.RArray.toExpr | Lean.Data.RArray | {α : Type u_1} → Lean.Expr → (α → Lean.Expr) → Lean.RArray α → Lean.MetaM Lean.Expr | null | true |
Std.Mutex.mutex | Std.Sync.Mutex | {α : Type} → Std.Mutex α → Std.BaseMutex | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers.0.CategoryTheory.NormalMonoCategory.pullback_of_mono.match_1_3 | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Equalizers | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasFiniteProducts C] [inst_3 : CategoryTheory.Limits.HasKernels C] {X Z : C}
(a : X ⟶ Z) (P : C) (f : Z ⟶ P) (haf : CategoryTheory.CategoryStruct.comp a f = 0) (Q : C) (... | null | false |
PresheafOfModules.Sheafify.SMulCandidate.casesOn | Mathlib.Algebra.Category.ModuleCat.Presheaf.Sheafify | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{R₀ : CategoryTheory.Functor Cᵒᵖ RingCat} →
{R : CategoryTheory.Sheaf J RingCat} →
{α : R₀ ⟶ R.obj} →
{M₀ : PresheafOfModules R₀} →
{A : CategoryTheory.Shea... | null | false |
Vector.insertIdx | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → Vector α n → (i : ℕ) → α → autoParam (i ≤ n) Vector.insertIdx._auto_1 → Vector α (n + 1) | Insert an element into a vector using a `Nat` index and a tactic provided proof. | true |
MulOpposite.op_ne_zero_iff | Mathlib.Algebra.Opposites | ∀ {α : Type u_1} [inst : Zero α] (a : α), MulOpposite.op a ≠ 0 ↔ a ≠ 0 | null | true |
Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | Type | null | true |
two_nsmul_inf_eq_add_sub_abs_sub | Mathlib.Algebra.Order.Group.Unbundled.Abs | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : AddCommGroup α] [AddLeftMono α] (a b : α), 2 • (a ⊓ b) = a + b - |b - a| | null | true |
Class._aux_Mathlib_SetTheory_ZFC_Class___unexpand_Class_sUnion_1 | Mathlib.SetTheory.ZFC.Class | Lean.PrettyPrinter.Unexpander | null | false |
List.isSome_isPrefixOf?_eq_isPrefixOf | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α] (xs ys : List α), (xs.isPrefixOf? ys).isSome = xs.isPrefixOf ys | null | true |
Lean.Lsp.TextDocumentEdit.mk.sizeOf_spec | Lean.Data.Lsp.Basic | ∀ (textDocument : Lean.Lsp.VersionedTextDocumentIdentifier) (edits : Lean.Lsp.TextEditBatch),
sizeOf { textDocument := textDocument, edits := edits } = 1 + sizeOf textDocument + sizeOf edits | null | true |
_private.Mathlib.Combinatorics.Enumerative.Composition.0.Composition.recOnSingleAppend.match_3.eq_1 | Mathlib.Combinatorics.Enumerative.Composition | ∀ (motive : (n : ℕ) → Composition n → Sort u_1) (blocks : List ℕ) (blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i)
(h_1 :
(blocks : List ℕ) →
(blocks_pos : ∀ {i : ℕ}, i ∈ blocks → 0 < i) →
motive blocks.sum { blocks := blocks, blocks_pos := blocks_pos, blocks_sum := ⋯ }),
(match blocks.sum, { blocks :... | null | true |
MulAction.isTopologicallyTransitive_iff | Mathlib.Dynamics.Transitive | ∀ (M : Type u_1) {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : Monoid M] [inst_2 : MulAction M α],
MulAction.IsTopologicallyTransitive M α ↔
∀ {U V : Set α}, IsOpen U → U.Nonempty → IsOpen V → V.Nonempty → ∃ m, (m • U ∩ V).Nonempty | null | true |
EuclideanGeometry.inner_pos_or_eq_of_dist_le_radius | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
p₁ ∈ s → dist p₂ s.center ≤ s.radius → 0 < inner ℝ (p₁ -ᵥ p₂) (p₁ -ᵥ s.center) ∨ p₁ = p₂ | Given a point on a sphere and a point not outside it, the inner product between the
difference of those points and the radius vector is positive unless the points are equal. | true |
ProbabilityTheory.exponentialPDF_of_nonneg | Mathlib.Probability.Distributions.Exponential | ∀ {r x : ℝ}, 0 ≤ x → ProbabilityTheory.exponentialPDF r x = ENNReal.ofReal (r * Real.exp (-(r * x))) | null | true |
Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?!_snd | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {v : β},
(Std.DTreeMap.Internal.Impl.Const.getThenInsertIfNew?! t k v).2 = Std.DTreeMap.Internal.Impl.insertIfNew! k v t | null | true |
Lean.Elab.Do.ControlLifter.mk | Lean.Elab.Do.Control | Lean.Elab.Do.DoElemCont →
Option Lean.Elab.Do.ControlStack →
Option Lean.Elab.Do.ControlStack →
Option Lean.Elab.Do.ControlStack →
Lean.Elab.Do.ControlStack → Lean.Elab.Do.CodeLiveness → Lean.Expr → Lean.Elab.Do.ControlLifter | null | true |
Lean.Linter.whenLinterActivated | Mathlib.Lean.Linter | Lean.Option Bool → Lean.Elab.Command.CommandElab → optParam Bool true → Lean.Elab.Command.CommandElab | Processes `set_option ... in`s that wrap the input `stx`, then acts on the inner syntax with
`x` after checking that the provided linter option is `true`.
If `breakOnError` is `true` (the default), avoids running the linter when errors are present.
This is typically used to start off linter code:
```
def myLinter : L... | true |
HasFPowerSeriesAt.hasFDerivAt | Mathlib.Analysis.Calculus.FDeriv.Analytic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type v} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
{p : FormalMultilinearSeries 𝕜 E F} {f : E → F} {x : E},
HasFPowerSeriesAt f p x → HasFDerivAt f ((continuousMult... | null | true |
SpecialLinearGroup.SL2Z_generators | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | Subgroup.closure {ModularGroup.S, ModularGroup.T} = ⊤ | `SL(2, ℤ)` is generated by `S` and `T`. | true |
Int64.toUInt64_neg | Init.Data.SInt.Lemmas | ∀ (a : Int64), (-a).toUInt64 = -a.toUInt64 | null | true |
LaurentSeries.ratfuncAdicComplRingEquiv._proof_3 | Mathlib.RingTheory.LaurentSeries | ∀ (K : Type u_1) [inst : Field K] (x y : LaurentSeries.RatFuncAdicCompl K),
(LaurentSeries.comparePkg K).toFun (x * y) =
(LaurentSeries.comparePkg K).toFun x * (LaurentSeries.comparePkg K).toFun y | null | false |
Finset.cons.congr_simp | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} (a a_1 : α) (e_a : a = a_1) (s s_1 : Finset α) (e_s : s = s_1) (h : a ∉ s),
Finset.cons a s h = Finset.cons a_1 s_1 ⋯ | null | true |
Fintype.card_lt_of_injective_of_notMem | Mathlib.Data.Fintype.Card | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (f : α → β),
Function.Injective f → ∀ {b : β}, b ∉ Set.range f → Fintype.card α < Fintype.card β | null | true |
_private.Lean.Meta.ExprDefEq.0.Lean.Meta.mkLambdaFVarsWithLetDeps | Lean.Meta.ExprDefEq | Array Lean.Expr → Lean.Expr → Lean.MetaM (Option Lean.Expr) | Auxiliary method for solving constraints of the form `?m xs := v`.
It creates a lambda using `mkLambdaFVars ys v`, where `ys` is a superset of `xs`.
`ys` is often equal to `xs`. It is a bigger when there are let-declaration dependencies in `xs`.
For example, suppose we have `xs` of the form `#[a, c]` where
```
a : Nat
... | true |
FiniteIndexNormalAddSubgroup.instSemilatticeInfFiniteIndexNormalAddSubgroup._proof_3 | Mathlib.GroupTheory.FiniteIndexNormalSubgroup | ∀ {G : Type u_1} [inst : AddGroup G] {x y : FiniteIndexNormalAddSubgroup G}, ↑y < ↑x ↔ ↑y < ↑x | null | false |
Multipliable.tprod_subtype_mul_tprod_subtype_compl | Mathlib.Topology.Algebra.InfiniteSum.Group | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : CommGroup α] [IsUniformGroup α] [CompleteSpace α]
[T2Space α] {f : β → α}, Multipliable f → ∀ (s : Set β), (∏' (x : ↑s), f ↑x) * ∏' (x : ↑sᶜ), f ↑x = ∏' (x : β), f x | null | true |
_private.Mathlib.RepresentationTheory.Continuous.TopRep.0.TopRep.Hom.ext.match_1 | Mathlib.RepresentationTheory.Continuous.TopRep | ∀ {k : Type u_1} {G : Type u_2} {inst : TopologicalSpace k} {inst_1 : Ring k} {inst_2 : IsTopologicalRing k}
{inst_3 : Monoid G} {A : TopRep k G} {B : TopRep k G} (motive : A.Hom B → Prop) (h : A.Hom B),
(∀ (hom' : ContIntertwiningMap A.ρ B.ρ), motive { hom' := hom' }) → motive h | null | false |
ContinuousAffineMap.comp_contLinear | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] {W₂ : Type u_6} {... | null | true |
Std.Do.PredTrans.const | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → Std.Do.Assertion ps → Std.Do.PredTrans ps α | The predicate transformer that always returns the same precondition `P`; `(const P).apply Q = P`.
| true |
_private.Mathlib.Analysis.SpecialFunctions.Pow.Real.0.Complex.ofReal_cpow._simp_1_1 | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {z : ℝ}, (↑z = 0) = (z = 0) | null | false |
Sym.countPerms_coe_fill_of_notMem | Mathlib.Data.Nat.Choose.Multinomial | ∀ {n : ℕ} {α : Type u_1} [inst : DecidableEq α] {m : Fin (n + 1)} {s : Sym α (n - ↑m)} {x : α},
x ∉ s → (↑(Sym.fill x m s)).countPerms = n.choose ↑m * (↑s).countPerms | null | true |
_private.Init.Data.SInt.Lemmas.0.Int64.lt_of_le_of_ne._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int64}, (x = y) = (x.toInt = y.toInt) | null | false |
DyckWord.ctorIdx | Mathlib.Combinatorics.Enumerative.DyckWord | DyckWord → ℕ | null | false |
_private.Mathlib.GroupTheory.SpecificGroups.Cyclic.0.IsAddCyclic.of_exponent_eq_card.match_1_1 | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {α : Type u_1} [inst : AddCommGroup α] (val : Fintype α)
(motive : (∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯) → Prop)
(x : ∃ a ∈ Finset.univ, addOrderOf a = (Finset.image addOrderOf Finset.univ).max' ⋯),
(∀ (g : α) (left : g ∈ Finset.univ) (hg : addOrderOf g = (Finset.image... | null | false |
Int64.shiftLeft_zero | Init.Data.SInt.Bitwise | ∀ {a : Int64}, a <<< 0 = a | null | true |
Std.IterM.toIter_mk | Init.Data.Iterators.Basic | ∀ {α β : Type u_1} {it : α}, { internalState := it }.toIter = { internalState := it } | null | true |
TopologicalSpace.gciGenerateFrom | Mathlib.Topology.Order | (α : Type u_1) →
GaloisCoinsertion (fun t => OrderDual.toDual {s | IsOpen s}) (TopologicalSpace.generateFrom ∘ ⇑OrderDual.ofDual) | The Galois coinsertion between `TopologicalSpace α` and `(Set (Set α))ᵒᵈ` whose lower part sends
a topology to its collection of open subsets, and whose upper part sends a collection of subsets
of `α` to the topology they generate. | true |
_private.Lean.Elab.Quotation.0.Lean.Elab.Term.Quotation.markRhss.match_1 | Lean.Elab.Quotation | (motive : Lean.TSyntax `term × Lean.TSyntax `term → Sort u_1) →
(x : Lean.TSyntax `term × Lean.TSyntax `term) → ((idx rhs : Lean.TSyntax `term) → motive (idx, rhs)) → motive x | null | false |
isArtinian_of_finite | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Finite M],
IsArtinian R M | null | true |
_private.Batteries.Data.List.Lemmas.0.List.countPBefore_cons_succ_of_pos._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {xs : List α} {i : ℕ} {a : α},
p a = true → List.countPBefore p (a :: xs) (i + 1) = List.countPBefore p xs i + 1 | null | false |
Std.TreeSet.instSliceableRocSlice | Std.Data.TreeSet.Slice | {α : Type u} →
(cmp : autoParam (α → α → Ordering) Std.TreeSet.instSliceableRocSlice._auto_1) →
Std.Roc.Sliceable (Std.TreeSet α cmp) α (Std.DTreeMap.Internal.Unit.RocSlice α) | null | true |
Vector.finRange_zero | Init.Data.Vector.FinRange | Vector.finRange 0 = #v[] | null | true |
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd'.congr_simp | Mathlib.CategoryTheory.Triangulated.TriangleShift | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] (a b n : ℤ)
(h : a + b = n),
CategoryTheory.Pretriangulated.Triangle.shiftFunctorAdd' C a b n h =
CategoryThe... | null | true |
IsLocalization.exists_mk'_eq | Mathlib.RingTheory.Localization.Defs | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R) {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (z : S), ∃ x y, IsLocalization.mk' S x y = z | null | true |
Lean.Elab.Level.Context.mk | Lean.Elab.Level | Lean.Options → Lean.Syntax → Bool → Lean.Elab.Level.Context | null | true |
_private.Mathlib.Data.Nat.Bitwise.0.Nat.xor_mod_two_eq._simp_1_6 | Mathlib.Data.Nat.Bitwise | ∀ {n : ℕ}, (n % 2 ≠ 0) = (n % 2 = 1) | null | false |
List.pair_mem_product | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {xs : List α} {ys : List β} {x : α} {y : β}, (x, y) ∈ xs.product ys ↔ x ∈ xs ∧ y ∈ ys | List.prod satisfies a specification of cartesian product on lists. | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushInstPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | null | true |
MeasureTheory.SimpleFunc.instNonAssocRing._proof_7 | Mathlib.MeasureTheory.Function.SimpleFunc | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : NonAssocRing β],
autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
_private.Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar.0.BoundedContinuousFunction.mem_charPoly._simp_1_1 | Mathlib.Analysis.Fourier.BoundedContinuousFunctionChar | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : PseudoMetricSpace β]
{f g : BoundedContinuousFunction α β}, (f = g) = ∀ (x : α), f x = g x | null | false |
NumberField.InfinitePlace.mk_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {φ : L →+* ℂ},
φ ∈ NumberField.ComplexEmbedding.mixedEmbeddingsOver L v.embedding →
NumberField.InfinitePlace.mk φ ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v | null | true |
Mathlib.Tactic.Push.elabHead | Mathlib.Tactic.Push | Lean.Term → Lean.Elab.TermElabM Mathlib.Tactic.Push.Head | Elaborator for the argument passed to `push`. It accepts a constant, or a function | true |
_private.Init.Data.List.Nat.BEq.0.List.beq_eq_isEqv._simp_1_2 | Init.Data.List.Nat.BEq | ∀ {n : ℕ} {p : (m : ℕ) → m < n + 1 → Prop},
(∀ (m : ℕ) (h : m < n + 1), p m h) = (p 0 ⋯ ∧ ∀ (m : ℕ) (h : m < n), p (m + 1) ⋯) | null | false |
Char.toUpper_toUpper_eq_toUpper | Batteries.Data.Char.AsciiCasing | ∀ (c : Char), c.toUpper.toUpper = c.toUpper | null | true |
Aesop.Frontend.RuleExpr.rec_1 | Aesop.Frontend.RuleExpr | {motive_1 : Aesop.Frontend.RuleExpr → Sort u} →
{motive_2 : Array Aesop.Frontend.RuleExpr → Sort u} →
{motive_3 : List Aesop.Frontend.RuleExpr → Sort u} →
((f : Aesop.Frontend.Feature) →
(children : Array Aesop.Frontend.RuleExpr) →
motive_2 children → motive_1 (Aesop.Frontend.RuleExpr.... | null | false |
LinearEquiv.toSpanNonzeroSingleton._proof_4 | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) (M : Type u_2) [inst : Ring R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[Module.IsTorsionFree R M] (x : M), x ≠ 0 → Function.Injective ⇑(LinearMap.toSpanSingleton R M x) | null | false |
Polynomial.algebra | Mathlib.RingTheory.PolynomialAlgebra | (R : Type u_1) →
(A : Type u_3) →
[inst : CommSemiring R] → [inst_1 : Semiring A] → [Algebra R A] → Algebra (Polynomial R) (Polynomial A) | If `A` is an `R`-algebra, then `A[X]` is an `R[X]` algebra.
This gives a diamond for `Algebra R[X] R[X][X]`, so this is not a global instance. | true |
CpltSepUniformSpace.ctorIdx | Mathlib.Topology.Category.UniformSpace | CpltSepUniformSpace → ℕ | null | false |
Nat.Partition.ofSums._proof_1 | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (l : Multiset ℕ) {i : ℕ}, i ∈ Multiset.filter (fun x => x ≠ 0) l → ⊥ < i | null | false |
ContinuousMulEquiv.trans.eq_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] {L : Type u_3} [inst_4 : Mul L] [inst_5 : TopologicalSpace L] (cme1 : M ≃ₜ* N) (cme2 : N ≃ₜ* L),
cme1.trans cme2 = { toMulEquiv := cme1.trans cme2.toMulEquiv, continuous_toFun := ⋯, continuous... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.three_le_length.match_1_3 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V}
(motive : (p : G.Walk v v) → p.IsCycle → p.IsTrail → p ≠ SimpleGraph.Walk.nil → p.support.tail.Nodup → Prop)
(p : G.Walk v v) (hp : p.IsCycle) (hp_1 : p.IsTrail) (hp' : p ≠ SimpleGraph.Walk.nil)
(support_nodup : p.support.tail.Nodup),
(∀ (hp : SimpleGraph.Walk.nil.Is... | null | false |
VitaliFamily.FineSubfamilyOn.covering.congr_simp | Mathlib.MeasureTheory.Covering.VitaliFamily | ∀ {X : Type u_1} [inst : PseudoMetricSpace X] {m0 : MeasurableSpace X} {μ : MeasureTheory.Measure X}
{v v_1 : VitaliFamily μ} (e_v : v = v_1) {f f_1 : X → Set (Set X)} (e_f : f = f_1) {s s_1 : Set X} (e_s : s = s_1)
(_h : v.FineSubfamilyOn f s) (a a_1 : X × Set X),
a = a_1 → ∀ (a_2 a_3 : X), a_2 = a_3 → _h.coveri... | null | true |
Std.Roc.lower | Init.Data.Range.Polymorphic.PRange | {α : Type u} → Std.Roc α → α | The lower bound of the range. `lower` is not included in the range.
| true |
NumberField.InfinitePlace.liesOver_embedding_of_mem_ramifiedPlacesOver | Mathlib.NumberTheory.NumberField.InfinitePlace.Ramification | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
{v : NumberField.InfinitePlace K} {w : NumberField.InfinitePlace L},
w ∈ NumberField.InfinitePlace.ramifiedPlacesOver L v → NumberField.ComplexEmbedding.LiesOver w.embedding v.embedding | null | true |
Std.DTreeMap.toList | Std.Data.DTreeMap.Basic | {α : Type u} → {β : α → Type v} → {cmp : α → α → Ordering} → Std.DTreeMap α β cmp → List ((a : α) × β a) | Transforms the tree map into a list of mappings in ascending order. | true |
_private.Mathlib.Data.Int.Interval.0.Finset.Ico_succ_succ._simp_1_2 | Mathlib.Data.Int.Interval | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | null | false |
List.filterMap_flatten | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {L : List (List α)},
List.filterMap f L.flatten = (List.map (List.filterMap f) L).flatten | null | true |
OrderMonoidIso.instEquivLike.eq_1 | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Mul α] [inst_3 : Mul β],
OrderMonoidIso.instEquivLike =
{ coe := fun f => f.toFun, inv := fun f => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ } | null | true |
isOpen_iff_ultrafilter | Mathlib.Topology.Ultrafilter | ∀ {X : Type u} {s : Set X} [inst : TopologicalSpace X], IsOpen s ↔ ∀ x ∈ s, ∀ (l : Ultrafilter X), ↑l ≤ nhds x → s ∈ l | null | true |
AddCommGrpCat.Forget₂.createsLimit._proof_7 | Mathlib.Algebra.Category.Grp.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(this : Small.{u_1, max u_1 u_3} ↑(F.comp (CategoryTheory.forget AddCommGrpCat)).sections)
(s : CategoryTheory.Limits.Cone F),
EquivLike.coe
(equivShrink
↑((F.comp
((Category... | null | false |
Hyperreal.infinitePos_mul_of_not_infinitesimal_pos_infinitePos | Mathlib.Analysis.Real.Hyperreal | ∀ {x y : ℝ*}, ¬x.Infinitesimal → 0 < x → y.InfinitePos → (x * y).InfinitePos | null | true |
Lean.Grind.IntInterval.isFinite.eq_4 | Init.Grind.ToInt | Lean.Grind.IntInterval.ii.isFinite = false | null | true |
IsLocalDiffeomorph.preimage_boundary | Mathlib.Geometry.Manifold.IsManifold.InteriorBoundary | ∀ {𝕜 : 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... | null | true |
Complex.cderiv._proof_1 | Mathlib.Analysis.Complex.LocallyUniformLimit | (1 + 1).AtLeastTwo | null | false |
Fin.castSucc_eq_zero_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {a : Fin n}, (a.castSucc = 0) = (a = 0) | null | false |
CategoryTheory.Abelian.SpectralObject.mono_map | Mathlib.Algebra.Homology.SpectralObject.EpiMono | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι) {i₀' i₀ i₁ i₂ i₃ : ι}
(f₁ : i₀ ⟶ i₁) (f₁' : i₀' ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃)
(α : CategoryTheory.... | null | true |
_private.Init.Data.String.Decode.0.parseFirstByte_eq_oneMore_of_utf8DecodeChar?_eq_some._proof_1_3 | Init.Data.String.Decode | ∀ {b : ByteArray} {i : ℕ} {c : Char}, c.utf8Size = 2 → c.utf8Size = 3 → False | null | false |
Complex.basisOneI._proof_6 | Mathlib.LinearAlgebra.Complex.Module | NeZero (1 + 1) | null | false |
_private.Mathlib.Algebra.Polynomial.Degree.Lemmas.0.Polynomial.degree_comp._simp_1_1 | Mathlib.Algebra.Polynomial.Degree.Lemmas | ∀ {R : Type u} [inst : Semiring R] [NoZeroDivisors R] {p q : Polynomial R},
(p.comp q = 0) = (p = 0 ∨ Polynomial.eval (q.coeff 0) p = 0 ∧ q = Polynomial.C (q.coeff 0)) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.