name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.Functor.lanUnit_app_whiskerLeft_lanAdjunction_counit_app_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] [inst_3 : ∀ (F : CategoryTheory.Functor C H), L.HasLeftKanExtension F]
(G : CategoryTheory.F... | null | true |
_private.Lean.Data.Iterators.Producers.PersistentHashMap.0.Lean.PersistentHashMap.Node.measure.measureEntries._mutual | Lean.Data.Iterators.Producers.PersistentHashMap | {α : Type u_1} →
{β : Type u_2} →
(x :
(_ : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β))) ×' ℕ ⊕'
Lean.PersistentHashMap.Node α β) →
PSum.casesOn x (fun _x => ℕ) fun _x => ℕ | Counts the total entries in an entries array starting at index `i`. | false |
NNReal.coe_inv._simp_1 | Mathlib.Data.NNReal.Defs | ∀ (r : NNReal), (↑r)⁻¹ = ↑r⁻¹ | null | false |
_private.Mathlib.Data.Vector.MapLemmas.0.List.Vector.mapAccumr_redundant_pair.match_1_1 | Mathlib.Data.Vector.MapLemmas | {σ : Type u_1} → (motive : σ × σ → Sort u_2) → (x : σ × σ) → ((s₁ s₂ : σ) → motive (s₁, s₂)) → motive x | null | false |
HasProdUniformlyOn.eq_1 | Mathlib.Topology.Algebra.InfiniteSum.UniformOn | ∀ {α : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : CommMonoid α] (f : ι → β → α) (g : β → α) (s : Set β)
[inst_1 : UniformSpace α],
HasProdUniformlyOn f g s = HasProd (⇑(UniformOnFun.ofFun {s}) ∘ f) ((UniformOnFun.ofFun {s}) g) | null | true |
Lean.Elab.PartialFixpointType.inductiveFixpoint | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType | null | true |
AddGroupSeminormClass.toSeminormedAddCommGroup_norm_eq | Mathlib.Analysis.Normed.Order.Hom.Basic | ∀ {F : Type u_1} {α : Type u_2} [inst : FunLike F α ℝ] [inst_1 : AddCommGroup α] [inst_2 : AddGroupSeminormClass F α ℝ]
(f : F) (x : α), ‖x‖ = f x | null | true |
_private.Lean.Elab.Tactic.Do.Internal.VCGen.Solve.0.Lean.Elab.Tactic.Do.Internal.VCGen.tryLetIntro | Lean.Elab.Tactic.Do.Internal.VCGen.Solve | Lean.MVarId → Lean.Expr → Lean.Elab.Tactic.Do.Internal.VCGenM (Option Lean.Elab.Tactic.Do.Internal.VCGen.SolveResult) | Strategy 7a: zeta-substitute (if the bound value is duplicable) or introduce a
top-level `let` in the target.
When `Context.useJP` is set and the let binds a `__do_jp` (do-elaborator-emitted
shared continuation) whose value is a function whose body is a splitter, we are
at the point where the upstream `mvcgen.onJoinPo... | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.div._unary._proof_4 | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (a₁ : ℤ) (x₁ : Q(«$M»)) (k₁ : ℕ) (t₁ : List ((ℤ × Q(«$M»)) × ℕ)) (a₂ : ℤ)
(x₂ : Q(«$M»)) (k₂ : ℕ) (t₂ : List ((ℤ × Q(«$M»)) × ℕ)),
(invImage (fun x => PSigma.casesOn x fun a a_1 => (a, a_1)) Prod.instWellFoundedRelation).1 ⟨((a₁, x₁), k₁) :: t₁, t₂⟩
⟨((a₁, x₁), k₁) :: t₁, ((a₂... | null | false |
_private.Mathlib.CategoryTheory.Subobject.Limits.0.CategoryTheory.Limits.kernelOrderHom._simp_1 | Mathlib.CategoryTheory.Subobject.Limits | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : X ≅ Y) {f : X ⟶ Z} {g : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp α.hom g = f) = (g = CategoryTheory.CategoryStruct.comp α.inv f) | null | false |
_private.Mathlib.Analysis.Normed.Operator.NormedSpace.0.ContinuousLinearMap.opNNNorm_comp_linearIsometryEquiv._simp_1_1 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NontriviallyNormedField 𝕜₂] [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [inst_6 : RingHomIsometric σ... | null | false |
List.find?_eq_head?_dropWhile_not | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} (p : α → Bool) (l : List α), List.find? p l = (List.dropWhile (fun x => !p x) l).head? | null | true |
_private.Lean.Elab.BuiltinNotation.0.Lean.Elab.Term.elabAnonymousCtor._sparseCasesOn_1 | Lean.Elab.BuiltinNotation | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Lean.Elab.PreDefinition.PartialFixpoint.Eqns.0.Lean.Elab.PartialFixpoint.deltaLHSUntilFix | Lean.Elab.PreDefinition.PartialFixpoint.Eqns | Lean.Name → Lean.Name → Lean.MVarId → Lean.MetaM Lean.MVarId | null | true |
Submodule.finiteQuotientOfFreeOfRankEq | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | ∀ {M : Type u_3} [inst : AddCommGroup M] [Module.Free ℤ M] [Module.Finite ℤ M] (N : Submodule ℤ M),
Module.finrank ℤ ↥N = Module.finrank ℤ M → Finite (M ⧸ N) | A submodule of full rank of a free finite `ℤ`-module has a finite quotient.
It can't be an instance because of the side condition `Module.finrank ℤ N = Module.finrank ℤ M`.
| true |
Mathlib.Tactic.FieldSimp.NF.one_eq_eval | Mathlib.Tactic.FieldSimp.Lemmas | ∀ (M : Type u_1) [inst : GroupWithZero M], 1 = Mathlib.Tactic.FieldSimp.NF.eval [] | null | true |
Alexandrov.self_mem_principalOpen | Mathlib.Topology.Sheaves.Alexandrov | ∀ {X : Type v} [inst : TopologicalSpace X] [inst_1 : Preorder X] [inst_2 : Topology.IsUpperSet X] (x : X),
x ∈ Alexandrov.principalOpen x | null | true |
Turing.ToPartrec.Code.comp.injEq | Mathlib.Computability.TuringMachine.Config | ∀ (a a_1 a_2 a_3 : Turing.ToPartrec.Code), (a.comp a_1 = a_2.comp a_3) = (a = a_2 ∧ a_1 = a_3) | null | true |
Lex.instNonAssocRing | Mathlib.Algebra.Order.Ring.Synonym | {R : Type u_1} → [NonAssocRing R] → NonAssocRing (Lex R) | null | true |
Topology.«_aux_Mathlib_Topology_Baire_BaireMeasurable___macroRules_Topology_term∀ᵇ_,__1» | Mathlib.Topology.Baire.BaireMeasurable | Lean.Macro | null | false |
HAnd.rec | Init.Prelude | {α : Type u} →
{β : Type v} →
{γ : Type w} →
{motive : HAnd α β γ → Sort u_1} → ((hAnd : α → β → γ) → motive { hAnd := hAnd }) → (t : HAnd α β γ) → motive t | null | false |
UInt32.toFin_ofNatClamp_of_le._proof_1 | Init.Data.UInt.Lemmas | UInt32.size - 1 < UInt32.size | null | false |
Algebra.subset_adjoin | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ {R : Type uR} {A : Type uA} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {s : Set A},
s ⊆ ↑(Algebra.adjoin R s) | null | true |
Std.Rxc.size_pos_iff_le | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, 0 < Std.Rxc.HasSize.size lo hi ↔ lo ≤ hi | null | true |
TopologicalSpace.CompactOpens.coe_himp._simp_1 | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : CompactSpace α] [inst_2 : T2Space α]
(s t : TopologicalSpace.CompactOpens α), ↑s ⇨ ↑t = ↑(s ⇨ t) | null | false |
MeasureTheory.VectorMeasure.«_aux_Mathlib_MeasureTheory_VectorMeasure_Integral___delab_app_MeasureTheory_VectorMeasure_term∫ᵛ_In_,_∂<•__1» | Mathlib.MeasureTheory.VectorMeasure.Integral | Lean.PrettyPrinter.Delaborator.Delab | Pretty printer defined by `notation3` command. | false |
CauchyFilter.mem_uniformity | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, CauchyFilter.gen t ⊆ s | null | true |
Std.HashMap.Raw.getKeyD_empty | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] {a fallback : α}, ∅.getKeyD a fallback = fallback | null | true |
floorDiv_of_nonpos | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : SMulZeroClass α β] [inst_5 : FloorDiv α β] {a : α}, a ≤ 0 → ∀ (b : β), b ⌊/⌋ a = 0 | null | true |
Std.ExtTreeMap.getElem_modify | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k k' : α}
{f : β → β} {hc : k' ∈ t.modify k f}, (t.modify k f)[k'] = if heq : cmp k k' = Ordering.eq then f t[k] else t[k'] | null | true |
hasDerivAtFilter_iff_tendsto | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {L : Filter (𝕜 × 𝕜)},
HasDerivAtFilter f f' L ↔ Filter.Tendsto (fun p => ‖p.1 - p.2‖⁻¹ * ‖f p.1 - f p.2 - (p.1 - p.2) • f'‖) L (nhds 0) | null | true |
Matroid.isNonloop_of_not_isLoop._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | null | false |
_private.Mathlib.RingTheory.Polynomial.Dickson.0.Polynomial.dickson.match_1.eq_1 | Mathlib.RingTheory.Polynomial.Dickson | ∀ (motive : ℕ → Sort u_1) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1) (h_3 : (n : ℕ) → motive n.succ.succ),
(match 0 with
| 0 => h_1 ()
| 1 => h_2 ()
| n.succ.succ => h_3 n) =
h_1 () | null | true |
CategoryTheory.Precoverage.toGrothendieck_le_iff_le_toPrecoverage | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {K : CategoryTheory.Precoverage C}
{J : CategoryTheory.GrothendieckTopology C}, K.toGrothendieck ≤ J ↔ K ≤ J.toPrecoverage | `toGrothendieck` and `toPrecoverage` form a Galois connection. | true |
MeasureTheory.Measure.restrict_toOuterMeasure_eq_toOuterMeasure_restrict | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α},
MeasurableSet s → (μ.restrict s).toOuterMeasure = (MeasureTheory.OuterMeasure.restrict s) μ.toOuterMeasure | This lemma shows that `restrict` and `toOuterMeasure` commute. Note that the LHS has a
restrict on measures and the RHS has a restrict on outer measures. | true |
Lean.Elab.Tactic.nonempty_prop_to_inhabited | Mathlib.Tactic.Inhabit | (α : Prop) → Nonempty α → Inhabited α | Derives `Inhabited α` from `Nonempty α` without `Classical.choice`
assuming `α` is of type `Prop`. | true |
Lean.LOption.some.sizeOf_spec | Lean.Data.LOption | ∀ {α : Type u} [inst : SizeOf α] (a : α), sizeOf (Lean.LOption.some a) = 1 + sizeOf a | null | true |
_private.Mathlib.Algebra.Notation.Support.0.Function.mulSupport_curry._simp_1_1 | Mathlib.Algebra.Notation.Support | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
Order.pred_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a ⋖ a | null | true |
IsLocalization.isRegular_mk'._simp_1 | 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],
(∀ m ∈ M, IsRegular m) → ∀ {r : R} {m : ↥M}, IsRegular (IsLocalization.mk' S r m) = IsRegular r | null | false |
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux.congr_simp | Mathlib.NumberTheory.LSeries.PrimesInAP | ∀ {q : ℕ} (a a_1 : ZMod q),
a = a_1 →
∀ [inst : NeZero q] (s s_1 : ℂ),
s = s_1 →
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux a s =
ArithmeticFunction.vonMangoldt.LFunctionResidueClassAux a_1 s_1 | null | true |
Lean.Meta.Sym.Arith.instInhabitedSemiring.default | Lean.Meta.Sym.Arith.Types | Lean.Meta.Sym.Arith.Semiring | null | true |
Set.insert_prod | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {t : Set β} {a : α}, insert a s ×ˢ t = Prod.mk a '' t ∪ s ×ˢ t | null | true |
CategoryTheory.InjectiveResolution.instInjectiveXIntCochainComplex | Mathlib.CategoryTheory.Abelian.Injective.Extend | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Preadditive C] {X : C} (R : CategoryTheory.InjectiveResolution X) (n : ℤ),
CategoryTheory.Injective (R.cochainComplex.X n) | null | true |
Module.Baer.ExtensionOfMaxAdjoin.fst | Mathlib.Algebra.Module.Injective | {R : Type u} →
[inst : Ring R] →
{Q : Type v} →
[inst_1 : AddCommGroup Q] →
[inst_2 : Module R Q] →
{M : Type u_1} →
{N : Type u_2} →
[inst_3 : AddCommGroup M] →
[inst_4 : AddCommGroup N] →
[inst_5 : Module R M] →
... | If `x ∈ M ⊔ ⟨y⟩`, then `x = m + r • y`, `fst` pick an arbitrary such `m`. | true |
SheafOfModules.GeneratingSections.IsFiniteType.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Generators | ∀ {C : Type u'} [inst : CategoryTheory.Category.{v', u'} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : CategoryTheory.HasWeakSheafify J AddCommGrpCat]
[inst_2 : J.WEqualsLocallyBijective AddCommGrpCat]
[inst_3 : J.HasSheafCompose (CategoryTheory.forget₂ RingCat AddC... | null | true |
CategoryTheory.GrothendieckTopology.diagramFunctor_map | Mathlib.CategoryTheory.Sites.Plus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) (D : Type w)
[inst_1 : CategoryTheory.Category.{w', w} D]
[inst_2 :
∀ (P : CategoryTheory.Functor Cᵒᵖ D) (X : C) (S : J.Cover X), CategoryTheory.Limits.HasMultiequalizer (S.index P)]
(X : C) {X_1 Y : CategoryT... | null | true |
Batteries.TotalBLE.recOn | Batteries.Classes.Order | {α : Sort u_1} →
{le : α → α → Bool} →
{motive : Batteries.TotalBLE le → Sort u} →
(t : Batteries.TotalBLE le) → ((total : ∀ {a b : α}, le a b = true ∨ le b a = true) → motive ⋯) → motive t | null | false |
ProfiniteAddGrp.recOn | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | {motive : ProfiniteAddGrp.{u} → Sort u_1} →
(t : ProfiniteAddGrp.{u}) →
((toProfinite : Profinite) →
[addGroup : AddGroup ↑toProfinite.toTop] →
[topologicalAddGroup : IsTopologicalAddGroup ↑toProfinite.toTop] →
motive { toProfinite := toProfinite, addGroup := addGroup, topologicalAdd... | null | false |
ContinuousEval.toContinuousEvalConst | Mathlib.Topology.Hom.ContinuousEval | ∀ {F : Type u_1} {X : Type u_2} {Y : Type u_3} [inst : FunLike F X Y] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace X] [inst_3 : TopologicalSpace Y] [ContinuousEval F X Y], ContinuousEvalConst F X Y | null | true |
Lean.Grind.AC.Seq.subseq | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.SubseqResult | `s₁.subseq s₂` checks whether `s₁` is a subsequence of `s₂`
| true |
CompHausLike.mk.congr_simp | Mathlib.Condensed.Light.Sequence | ∀ {P : TopCat → Prop} (toTop toTop_1 : TopCat) (e_toTop : toTop = toTop_1) [is_compact : CompactSpace ↑toTop]
[is_hausdorff : T2Space ↑toTop] (prop : P toTop),
{ toTop := toTop, is_compact := is_compact, is_hausdorff := is_hausdorff, prop := prop } =
{ toTop := toTop_1, is_compact := ⋯, is_hausdorff := ⋯, prop ... | null | true |
CategoryTheory.Span.Hom.noConfusion | Mathlib.CategoryTheory.Bicategory.Span.Basic | {P : Sort u} →
{C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{Wₗ Wᵣ : CategoryTheory.MorphismProperty C} →
{c c' : C} →
{S₁ S₂ : CategoryTheory.Span Wₗ Wᵣ c c'} →
{t : S₁.Hom S₂} →
{C' : Type u_1} →
{inst' : CategoryTheory.Catego... | null | false |
Perfection.coeffMonoidHom_pow_p_pow_self | Mathlib.RingTheory.Perfection | ∀ {M : Type u_1} [inst : CommMonoid M] {p : ℕ} (f : Perfection M p) (n : ℕ),
(Perfection.coeffMonoidHom M p n) f ^ p ^ n = (Perfection.coeffMonoidHom M p 0) f | null | true |
AddSubmonoid.mk._flat_ctor | Mathlib.Algebra.Group.Submonoid.Defs | {M : Type u_3} →
[inst : AddZeroClass M] →
(carrier : Set M) → (∀ {a b : M}, a ∈ carrier → b ∈ carrier → a + b ∈ carrier) → 0 ∈ carrier → AddSubmonoid M | null | false |
Order.Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Ioc (Order.pred b) a = Set.Icc b a | null | true |
Std.ExtTreeMap.getEntryGED | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → α × β → α × β | Tries to retrieve the key-value pair with the smallest key that is greater than or equal to the
given key, returning `fallback` if no such pair exists.
| true |
MulAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X] {N : Subgroup G} [N.Normal] (a : X),
MulAction.IsBlock G (MulAction.orbit (↥N) a) | An orbit of a normal subgroup is a block | true |
_private.Mathlib.MeasureTheory.Measure.Portmanteau.0.MeasureTheory.limsup_measure_closed_le_of_forall_tendsto_measure._simp_1_7 | Mathlib.MeasureTheory.Measure.Portmanteau | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Iio b) = (x < b) | null | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_eq_append_iff_of_size_eq_left._simp_1_1 | Init.Data.ByteArray.Lemmas | ∀ {x y : ByteArray}, (x = y) = (x.data = y.data) | null | false |
Lean.instHashableFVarId.hash | Lean.Expr | Lean.FVarId → UInt64 | null | true |
Mathlib.Tactic.LibraryRewrite.RewriteInterface.tactic | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.RewriteInterface → String | The rewrite tactic string that performs the rewrite | true |
of_isDiscreteValuationRing | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ (A : Type u) [inst : CommRing A] [inst_1 : IsDomain A] [IsDiscreteValuationRing A], ValuationRing A | A DVR is a valuation ring. | true |
and_congr_left' | Init.PropLemmas | ∀ {a b c : Prop}, (a ↔ b) → (a ∧ c ↔ b ∧ c) | null | true |
Lean.Lsp.instToJsonDeclarationParams.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DeclarationParams → Lean.Json | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.0.BitVec.reduceUnary.match_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | (motive : Option BitVec.Literal → Sort u_1) →
(__x : Option BitVec.Literal) →
((v : BitVec.Literal) → motive (some v)) → ((x : Option BitVec.Literal) → motive x) → motive __x | null | false |
isStrongAntichain_insert | Mathlib.Order.Antichain | ∀ {α : Type u_1} {r : α → α → Prop} {s : Set α} {a : α},
IsStrongAntichain r (insert a s) ↔ IsStrongAntichain r s ∧ ∀ ⦃b : α⦄, b ∈ s → a ≠ b → ∀ (c : α), ¬r a c ∨ ¬r b c | null | true |
List.Nodup.append | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Nodup → l₂.Nodup → l₁.Disjoint l₂ → (l₁ ++ l₂).Nodup | null | true |
instCoeLieSubalgebraSubmodule | Mathlib.Algebra.Lie.Subalgebra | (R : Type u) →
(L : Type v) →
[inst : CommRing R] → [inst_1 : LieRing L] → [inst_2 : LieAlgebra R L] → Coe (LieSubalgebra R L) (Submodule R L) | null | true |
Lean.Grind.CommRing.eq_normS_cert | Init.Grind.Ring.CommSemiringAdapter | Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr → Bool | null | true |
StarSubalgebra.toNonUnitalStarSubalgebra._proof_1 | Mathlib.Algebra.Star.Subalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : Semiring A]
[inst_3 : StarRing A] [inst_4 : Algebra R A] [inst_5 : StarModule R A] (S : StarSubalgebra R A) {a b : A},
a ∈ S.carrier → b ∈ S.carrier → a + b ∈ S.carrier | null | false |
Metric.packingNumber_pos_iff._simp_1 | Mathlib.Topology.MetricSpace.CoveringNumbers | ∀ {X : Type u_1} [inst : PseudoEMetricSpace X] {A : Set X} {ε : NNReal}, (0 < Metric.packingNumber ε A) = A.Nonempty | null | false |
AlgebraicGeometry.PresheafedSpace.GlueData._sizeOf_inst | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | (C : Type u) →
{inst : CategoryTheory.Category.{v, u} C} → [SizeOf C] → SizeOf (AlgebraicGeometry.PresheafedSpace.GlueData C) | null | false |
CategoryTheory.Adjunction.leftAdjointUniq | Mathlib.CategoryTheory.Adjunction.Unique | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F F' : CategoryTheory.Functor C D} → {G : CategoryTheory.Functor D C} → (F ⊣ G) → (F' ⊣ G) → (F ≅ F') | If `F` and `F'` are both left adjoint to `G`, then they are naturally isomorphic. | true |
_private.Mathlib.CategoryTheory.Functor.Category.0.CategoryTheory.flipFunctor._proof_5 | Mathlib.CategoryTheory.Functor.Category | ∀ (C : Type u_4) [inst : CategoryTheory.Category.{u_3, u_4} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_2) [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
(X : CategoryTheory.Functor C (CategoryTheory.Functor D E)) (x : D) (x_1 : C),
({ app := fun Y => { app := fun X_1 => ((Categ... | null | false |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_le_infEDist_add_hausdorffEDist._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u_1} {a : α} [inst : PartialOrder α] [inst_1 : Zero α] [IsBotZeroClass α], (0 < a) = (a ≠ 0) | null | false |
_private.Mathlib.Data.Finset.Powerset.0.Finset.powersetCard_map._simp_1_3 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s₁ s₂ : Finset α}, (Finset.map f s₁ ⊆ Finset.map f s₂) = (s₁ ⊆ s₂) | null | false |
_private.Init.Data.List.Lemmas.0.List.flatten.match_1.eq_2 | Init.Data.List.Lemmas | ∀ {α : Type u_1} (motive : List (List α) → Sort u_2) (l : List α) (L : List (List α)) (h_1 : Unit → motive [])
(h_2 : (l : List α) → (L : List (List α)) → motive (l :: L)),
(match l :: L with
| [] => h_1 ()
| l :: L => h_2 l L) =
h_2 l L | null | true |
_private.Lean.Parser.Term.0.Lean.Parser.Term.noErrorIfUnused._regBuiltin.Lean.Parser.Term.noErrorIfUnused.declRange_5 | Lean.Parser.Term | IO Unit | null | false |
_private.Lean.Elab.Term.TermElabM.0.Lean.Elab.Term.collectUnassignedMVars.go.match_1 | Lean.Elab.Term.TermElabM | (motive : List Lean.MVarId → Sort u_1) →
(mvarIds : List Lean.MVarId) →
(Unit → motive []) →
((mvarId : Lean.MVarId) → (mvarIds : List Lean.MVarId) → motive (mvarId :: mvarIds)) → motive mvarIds | null | false |
AddEquiv.toLinearEquiv._proof_3 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {M : Type u_1} {M₂ : Type u_2} [inst : AddCommMonoid M] [inst_1 : AddCommMonoid M₂] (e : M ≃+ M₂),
Function.RightInverse e.invFun e.toFun | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop.0.Std.IterM.step_drop.match_1.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.Drop | ∀ (motive : ℕ → Sort u_1) (h_1 : 0 = 0 → motive 0) (h_2 : (k : ℕ) → 0 = k.succ → motive k.succ),
(match h' : 0 with
| 0 => h_1 h'
| k.succ => h_2 k h') =
h_1 ⋯ | null | true |
equicontinuousAt_iff_range | Mathlib.Topology.UniformSpace.Equicontinuity | ∀ {ι : Type u_1} {X : Type u_3} {α : Type u_6} [tX : TopologicalSpace X] [uα : UniformSpace α] {F : ι → X → α} {x₀ : X},
EquicontinuousAt F x₀ ↔ EquicontinuousAt Subtype.val x₀ | A family `𝓕 : ι → X → α` is equicontinuous at `x₀` iff `range 𝓕` is equicontinuous at `x₀`,
i.e the family `(↑) : range F → X → α` is equicontinuous at `x₀`. | true |
Std.Internal.List.maxKey?_le_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] [inst_2 : BEq α] [inst_3 : Std.LawfulBEqOrd α]
{k km : α} {l : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l →
∀ (hc : Std.Internal.List.containsKey k l = true),
(Std.Internal.List.maxKey? l).get ⋯ = km → (compare k km).isL... | null | true |
_private.Lean.Elab.Tactic.Grind.Param.0.Lean.Meta.Grind.Params.containsEMatch | Lean.Elab.Tactic.Grind.Param | Lean.Meta.Grind.Params → Lean.Name → Bool | null | true |
AddCommGroup.modEq_iff_natModEq | Mathlib.Data.Nat.ModEq | ∀ {a b n : ℕ}, a ≡ b [PMOD n] ↔ a ≡ b [MOD n] | null | true |
iteratedDerivWithin_fun_sum | Mathlib.Analysis.Calculus.IteratedDeriv.Lemmas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {ι : Type u_7} {n : ℕ} {x : 𝕜} {f : ι → 𝕜 → F} {I : Finset ι} {s : Set 𝕜},
x ∈ s →
UniqueDiffOn 𝕜 s →
(∀ i ∈ I, ContDiffWithinAt 𝕜 (↑n) (f i) s x) →
iteratedDerivWi... | null | true |
AlgebraicGeometry.isAffineHom_of_isAffine | Mathlib.AlgebraicGeometry.Morphisms.Affine | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.IsAffine X] [AlgebraicGeometry.IsAffine Y],
AlgebraicGeometry.IsAffineHom f | null | true |
FirstOrder.Language.IsExtensionPair.definedAtLeft | Mathlib.ModelTheory.PartialEquiv | {L : FirstOrder.Language} →
{M : Type w} →
{N : Type w'} →
[inst : L.Structure M] → [inst_1 : L.Structure N] → L.IsExtensionPair M N → M → Order.Cofinal (L.FGEquiv M N) | The cofinal set of finite equivalences with a given element in their domain. | true |
Std.DHashMap.getD_modify | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [inst : LawfulBEq α] {k k' : α}
{fallback : β k'} {f : β k → β k},
(m.modify k f).getD k' fallback =
if heq : (k == k') = true then (Option.map (cast ⋯) (Option.map f (m.get? k))).getD fallback else m.getD k' fallback | null | true |
DirectSum.instCommRingOfNat._proof_7 | Mathlib.Algebra.DirectSum.Ring | ∀ {ι : Type u_1} [inst : DecidableEq ι] (A : ι → Type u_2) [inst_1 : (i : ι) → AddCommGroup (A i)]
[inst_2 : AddCommMonoid ι] [inst_3 : DirectSum.GCommRing A] (g h : A 0),
(DirectSum.of A 0) (g - h) = (DirectSum.of A 0) g - (DirectSum.of A 0) h | null | false |
Equiv.transPartialEquiv_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} (e : α ≃ β) (f' : PartialEquiv β γ),
(e.transPartialEquiv f').source = ⇑e ⁻¹' f'.source | null | true |
AddSubgroup.isComplement_iff_bijective | Mathlib.GroupTheory.Complement | ∀ {G : Type u_1} [inst : AddGroup G] {S : Type u_2} [inst_1 : SetLike S G] (s t : S),
AddSubgroup.IsComplement ↑s ↑t ↔ Function.Bijective fun x => ↑x.1 + ↑x.2 | The correct way to unfold `IsComplement` for `SetLike`s such as `AddSubgroup`s | true |
SSet.Subcomplex.Pairing.instIsWellFoundedElemNIIAncestralRel | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.Pairing | ∀ {X : SSet} {A : X.Subcomplex} (P : A.Pairing) [P.IsRegular], IsWellFounded (↑P.II) P.AncestralRel | null | true |
instToStringFormat | Init.Data.ToString.Basic | ToString Std.Format | null | true |
Vector.mem_append_right | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n m : ℕ} {a : α} (xs : Vector α n) {ys : Vector α m}, a ∈ ys → a ∈ xs ++ ys | null | true |
NonUnitalSubsemiring.closure_mono | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] ⦃s t : Set R⦄,
s ⊆ t → NonUnitalSubsemiring.closure s ≤ NonUnitalSubsemiring.closure t | Subsemiring closure of a set is monotone in its argument: if `s ⊆ t`,
then `closure s ≤ closure t`. | true |
Aesop.GoalKind.recOn | Aesop.Stats.Basic | {motive : Aesop.GoalKind → Sort u} →
(t : Aesop.GoalKind) → motive Aesop.GoalKind.preNorm → motive Aesop.GoalKind.postNorm → motive t | null | false |
FreeAddGroup.Red.negRev | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)},
FreeAddGroup.Red L₁ L₂ → FreeAddGroup.Red (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂) | null | true |
_private.Mathlib.Computability.TuringMachine.PostTuringMachine.0.Turing.TM0to1.tr.match_3.eq_2 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} (motive : Turing.TM0to1.Λ' Γ Λ → Sort u_3) (d : Turing.Dir) (q : Λ)
(h_1 : (q : Λ) → motive (Turing.TM0to1.Λ'.normal q))
(h_2 : (d : Turing.Dir) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0.Stmt.move d) q))
(h_3 : (a : Γ) → (q : Λ) → motive (Turing.TM0to1.Λ'.act (Turing.TM0... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.