name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
ENNReal.Lp_add_le | Mathlib.Analysis.MeanInequalities | ∀ {ι : Type u} (s : Finset ι) (f g : ι → ENNReal) {p : ℝ},
1 ≤ p → (∑ i ∈ s, (f i + g i) ^ p) ^ (1 / p) ≤ (∑ i ∈ s, f i ^ p) ^ (1 / p) + (∑ i ∈ s, g i ^ p) ^ (1 / p) | **Minkowski inequality**: the `L_p` seminorm of the sum of two vectors is less than or equal
to the sum of the `L_p`-seminorms of the summands. A version for `ℝ≥0∞`-valued nonnegative
functions. | true |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.isStarNormal_of_mem._simp_1_2 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u} [inst : Mul R] [inst_1 : HasDistribNeg R] {a b : R}, Commute a b → Commute (-a) b = True | null | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.IsPos.or_neg._proof_1_2 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {P : RootPairing ι R M N} (b : P.Base)
[inst_5 : CharZero R] (i : ι), b.height i ≠ 0 → 0 < b.height i ∨ 0 < -b.height i | null | false |
LinearMap.toMatrixₛₗ₂'_symm | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {R₁ : Type u_2} {S₁ : Type u_3} {R₂ : Type u_4} {S₂ : Type u_5} {N₂ : Type u_10} {n : Type u_11}
{m : Type u_12} [inst : CommSemiring R] [inst_1 : AddCommMonoid N₂] [inst_2 : Module R N₂] [inst_3 : Semiring R₁]
[inst_4 : Semiring R₂] [inst_5 : Semiring S₁] [inst_6 : Semiring S₂] [inst_7 : Module S₁... | null | true |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} (f : Equiv.Perm α), Equivalence f.SameCycle | null | true |
Lean.Widget.PanelWidgetInstance.mk.injEq | Lean.Widget.UserWidget | ∀ (toWidgetInstance : Lean.Widget.WidgetInstance) (range? : Option Lean.Lsp.Range) (name? : Option String)
(toWidgetInstance_1 : Lean.Widget.WidgetInstance) (range?_1 : Option Lean.Lsp.Range) (name?_1 : Option String),
({ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetIns... | null | true |
SheafOfModules.LocalGeneratorsData.quasiCoherentData._proof_2 | Mathlib.Algebra.Category.ModuleCat.Sheaf.LocallyFree | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
(q... | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findTactic?.merge._sparseCasesOn_3 | Lean.Server.CodeActions.Provider | {motive : Bool → Sort u} → (t : Bool) → motive false → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Assignment.0.Std.Tactic.BVDecide.LRAT.Internal.Assignment.extendOfClauseWithout_spec._simp_1_23 | Std.Tactic.BVDecide.LRAT.Internal.Assignment | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
LinearEquiv.domMulActCongrRight._proof_6 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R₁ : Type u_4} {R₁' : Type u_5} {R₂' : Type u_6} {M₁ : Type u_2} {M₁' : Type u_1} {M₂' : Type u_3}
[inst : Semiring R₁] [inst_1 : Semiring R₁'] [inst_2 : Semiring R₂'] [inst_3 : AddCommMonoid M₁]
[inst_4 : AddCommMonoid M₁'] [inst_5 : AddCommMonoid M₂'] [inst_6 : Module R₁ M₁] [inst_7 : Module R₁' M₁']
[inst_8... | null | false |
MulZeroClass.rec | Mathlib.Algebra.GroupWithZero.Defs | {M₀ : Type u} →
{motive : MulZeroClass M₀ → Sort u_1} →
([toMul : Mul M₀] →
[toZero : Zero M₀] →
(zero_mul : ∀ (a : M₀), 0 * a = 0) →
(mul_zero : ∀ (a : M₀), a * 0 = 0) →
motive { toMul := toMul, toZero := toZero, zero_mul := zero_mul, mul_zero := mul_zero }) →
(t... | null | false |
CategoryTheory.toOverIsoToOverUnit_hom_app_left | Mathlib.CategoryTheory.LocallyCartesianClosed.Over | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X : C),
(CategoryTheory.toOverIsoToOverUnit.hom.app X).left =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Over.Hom.left
(((CategoryTheory.mateEquiv
(CategoryThe... | null | true |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.testBit_two_pow_add_gt.match_1_1 | Init.Data.Nat.Bitwise.Lemmas | ∀ (motive : ℕ → Prop) (x : ℕ), (x = 0 → motive 0) → (∀ (d : ℕ), x = d.succ → motive d.succ) → motive x | null | false |
CategoryTheory.Coverage.mem_toGrothendieck | Mathlib.CategoryTheory.Sites.Coverage | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {K : CategoryTheory.Coverage C} {X : C}
{S : CategoryTheory.Sieve X}, S ∈ K.toGrothendieck X ↔ K.Saturate X S | null | true |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.isMulCommutative_iSup._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ p) = (x ∈ ↑p) | null | false |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {β : Type u_2} (a b : α ↪ β), ⇑a = ⇑b ↔ a = b | null | false |
CategoryTheory.Presheaf.compULiftYonedaIsoULiftYonedaCompLan.presheafHom | Mathlib.CategoryTheory.Limits.Presheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
{G :
CategoryTheory.Functor (CategoryTheory.Functor Cᵒᵖ (Type (max w v₁ v₂)))
(CategoryTheory.Funct... | Given functors `F : C ⥤ D` and
`G : (Cᵒᵖ ⥤ Type max w v₁ v₂) ⥤ (Dᵒᵖ ⥤ Type max w v₁ v₂)`,
and a natural transformation `φ : F ⋙ uliftYoneda ⟶ uliftYoneda ⋙ G`, this is the
(natural) morphism `P ⟶ F.op ⋙ G.obj P` for all `P : Cᵒᵖ ⥤ Type max w v₁ v₂` that is
determined by `φ`. | true |
Lean.Meta.Sym.State.casesOn | Lean.Meta.Sym.SymM | {motive : Lean.Meta.Sym.State → Sort u} →
(t : Lean.Meta.Sym.State) →
((share : Lean.Meta.Sym.AlphaShareCommon.State) →
(maxFVar : Lean.PHashMap Lean.Meta.Sym.ExprPtr (Option Lean.FVarId)) →
(proofInstInfo : Lean.PHashMap Lean.Name (Option Lean.Meta.Sym.ProofInstInfo)) →
(inferType :... | null | false |
HomotopicalAlgebra.Precylinder.symm_I | Mathlib.AlgebraicTopology.ModelCategory.Cylinder | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C} (P : HomotopicalAlgebra.Precylinder A), P.symm.I = P.I | null | true |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, Std.Commutative fun x y => x ||| y | null | true |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods.Commensurable 𝒢.periods | null | true |
SimpleGraph.FinsubgraphHom.restrict._proof_1 | Mathlib.Combinatorics.SimpleGraph.Finsubgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {G' G'' : G.Finsubgraph}, G'' ≤ G' → ∀ v ∈ (↑G'').verts, v ∈ (↑G').verts | null | false |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.emin = 1 - ↑FP.FloatCfg.emax | null | true |
IsRelUpperSet.iInter | Mathlib.Order.UpperLower.Relative | ∀ {α : Type u_1} {ι : Sort u_2} {P : α → Prop} [inst : LE α] [Nonempty ι] {f : ι → Set α},
(∀ (i : ι), IsRelUpperSet (f i) P) → IsRelUpperSet (⋂ i, f i) P | null | true |
List.Sublist.below | Init.Data.List.Basic | {α : Type u_1} → {motive : (a a_1 : List α) → a.Sublist a_1 → Prop} → {a a_1 : List α} → a.Sublist a_1 → Prop | null | true |
_private.Plausible.Attr.0.initFn._@.Plausible.Attr.3035915354._hygCtx._hyg.2 | Plausible.Attr | IO Unit | null | false |
SSet.Subcomplex.Pairing.RankFunction.w_assoc | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] (f : P.RankFunction ι)
[inst_1 : P.IsProper] [inst_2 : SuccOrder ι] [inst_3 : NoMaxOrder ι] (j : ι) {Z : SSet}
(h : (f.filtration (Order.succ j)).toSSet ⟶ Z),
CategoryTheory.CategoryStruct.comp (f.t j) (CategoryTheory.CategoryStru... | null | true |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : α), Function.Embedding.coeWithTop a = ↑a | null | true |
AddMonoid.Coprod.swap_comp_inr | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N],
(AddMonoid.Coprod.swap M N).comp AddMonoid.Coprod.inr = AddMonoid.Coprod.inl | null | true |
_private.Mathlib.Computability.Primrec.List.0.Primrec.listLookup._simp_1_2 | Mathlib.Computability.Primrec.List | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {a b : α}, ((a == b) = true) = (a = b) | null | false |
CategoryTheory.Limits.IndizationClosedUnderFilteredColimitsAux.compYonedaColimitIsoColimitCompYoneda | Mathlib.CategoryTheory.Limits.Indization.FilteredColimits | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{I : Type v} →
[inst_1 : CategoryTheory.SmallCategory I] →
(F : CategoryTheory.Functor I (CategoryTheory.Functor Cᵒᵖ (Type v))) →
{J : Type v} →
[inst_2 : CategoryTheory.SmallCategory J] →
(G :
... | (implementation) Pulling out a colimit out of a hom functor is one half of the key lemma. Note
that all of the heavy lifting actually happens in `CostructuredArrow.toOverCompYonedaColimit`
and `yonedaYonedaColimit`. | true |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact.Basic | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NontriviallyNormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ₁₂ : 𝕜₁ →+* 𝕜₂}
{M₁ : Type u_3} {M₂ : Type u_4} [inst_2 : SeminormedAddCommGroup M₁] [inst_3 : AddCommGroup M₂]
[inst_4 : NormedSpace 𝕜₁ M₁] [inst_5 : Module 𝕜₂ M₂] [inst_6 : UniformSpace M₂] [inst_7 : IsUnifor... | **Alias** of `isClosed_setOfPred_isCompactOperator`.
---
The set of compact operators from a normed space to a complete topological vector space is
closed. | true |
Nat.lt_irrefl | Init.Prelude | ∀ (n : ℕ), ¬n < n | null | true |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (x y : Fin n), x - y = x + -y | null | true |
_private.Mathlib.Probability.Process.Filtration.0.MeasureTheory.Filtration.wrapped._proof_1._@.Mathlib.Probability.Process.Filtration.2188831487._hygCtx._hyg.8 | Mathlib.Probability.Process.Filtration | @MeasureTheory.Filtration.definition✝ = @MeasureTheory.Filtration.definition✝ | null | false |
_private.Mathlib.NumberTheory.LSeries.Convergence.0.LSeriesSummable_of_abscissaOfAbsConv_lt_re._simp_1_2 | Mathlib.NumberTheory.LSeries.Convergence | ∀ {α : Type u_1} [inst : CompleteLinearOrder α] {s : Set α} {b : α}, (sInf s < b) = ∃ a ∈ s, a < b | null | false |
Lean.Elab.ConfigEval.instEvalExprOccurrences | Lean.Elab.ConfigEval.MetaInstances | Lean.Elab.ConfigEval.EvalExpr Lean.Meta.Occurrences | null | true |
CategoryTheory.Comonad.ForgetCreatesLimits'.liftedCone._proof_1 | Mathlib.CategoryTheory.Monad.Limits | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] {T : CategoryTheory.Comonad C}
{D : CategoryTheory.Functor J T.Coalgebra} (c : CategoryTheory.Limits.Cone (D.comp T.forget))
(t : CategoryTheory.Limits.IsLimit c) [inst_2 : CategoryTheory.... | null | false |
SimpleGraph.not_isUniform_iff | Mathlib.Combinatorics.SimpleGraph.Regularity.Uniform | ∀ {α : Type u_1} {𝕜 : Type u_2} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {G : SimpleGraph α}
[inst_3 : DecidableRel G.Adj] {ε : 𝕜} {s t : Finset α},
¬G.IsUniform ε s t ↔
∃ s' ⊆ s, ∃ t' ⊆ t, ↑s.card * ε ≤ ↑s'.card ∧ ↑t.card * ε ≤ ↑t'.card ∧ ε ≤ ↑|G.edgeDensity s' t' - G.edgeDensity ... | null | true |
ImportGraph.getWorkspaceModel | ImportGraph.WorkspaceModel.Build | optParam (Array Lean.Name) #[] →
optParam Bool true → optParam Bool true → optParam (Option System.FilePath) none → IO ImportGraph.WorkspaceModel | Gets the workspace model. This reads the `workspaceModelCache` `IO.Ref` if `useCache := true` (the default). Note that this does not perform validation. However, note that at least if the
imports to the current file are changed, the file will be restarted. We do not yet guarantee
validity of the cache in the case where... | true |
Float32.ofModel | Init.Data.Float.Float32 | Float32.Model → Float32 | Constructs a `Float32` from a `Float32.Model`. | true |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap α β cmp → δ | Folds the given function over the mappings in the map in ascending order. | true |
NonemptyInterval.mem_def | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : Preorder α] {s : NonemptyInterval α} {a : α}, a ∈ s ↔ s.toProd.1 ≤ a ∧ a ≤ s.toProd.2 | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey!_insertIfNew_le_minKey!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
_private.Mathlib.Data.List.Sort.0.List.orderedInsert.match_1.eq_2 | Mathlib.Data.List.Sort | ∀ {α : Type u_1} (motive : List α → Sort u_2) (b : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (b : α) → (l : List α) → motive (b :: l)),
(match b :: l with
| [] => h_1 ()
| b :: l => h_2 b l) =
h_2 b l | null | true |
Ordnode.findLeAux._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} →
[inst : LE α] → [DecidableLE α] → α → (x : Ordnode α) → Ordnode.below (motive := fun x => α → α) x → α → α | null | false |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | Std.HashSet Lean.FVarId → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches | Erase matches containing any of the hypotheses `hs` from `ms`. | true |
List.IsSuffix.isInfix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ | null | true |
_private.Init.Data.Int.DivMod.Bootstrap.0.Int.ofNat_dvd.match_1_3 | Init.Data.Int.DivMod.Bootstrap | ∀ {m n : ℕ} (motive : m ∣ n → Prop) (x : m ∣ n), (∀ (k : ℕ) (e : n = m * k), motive ⋯) → motive x | null | false |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | (prec emax : ℕ) → 0 < prec → prec ≤ emax → FP.FloatCfg | null | true |
_private.Init.Data.Nat.Div.Basic.0.Nat.sub_mul_div_of_le.match_1_1 | Init.Data.Nat.Div.Basic | ∀ (n : ℕ) (motive : n = 0 ∨ n > 0 → Prop) (x : n = 0 ∨ n > 0),
(∀ (h₀ : n = 0), motive ⋯) → (∀ (h₀ : n > 0), motive ⋯) → motive x | null | false |
Std.ExtTreeMap.get!_eq_getElem! | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, t.get! a = t[a]! | null | true |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → ℕ | null | false |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | ∀ {α : Type u_1} {r : α → α → Prop}, FaithfulSMul (r ≃r r) α | null | true |
ClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | A point `x` is a cluster point of a filter `F` if `𝓝 x ⊓ F ≠ ⊥`.
Also known as an accumulation point or a limit point, but beware that terminology varies.
This is *not* the same as asking `𝓝[≠] x ⊓ F ≠ ⊥`, which is called `AccPt` in Mathlib.
See `mem_closure_iff_clusterPt` in particular. | true |
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.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 |
Float.Model.ofInt64 | Init.Data.Float.Model.Float | Int64 → Float.Model | Converts an `Int64` to a `Float.Model`, returning positive zero on zero. | 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 |
_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 |
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 |
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 |
Matroid.isNonloop_of_not_isLoop._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | null | false |
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 |
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 |
Order.pred_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a ⋖ a | null | true |
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 |
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 |
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 |
DirectSum.instLieModuleSubtypeMemSubmodule | Mathlib.Algebra.Lie.Graded | ∀ {ι : Type u_1} {κ : Type u_2} {R : Type u_5} {L : Type u_6} {M : Type u_7} [inst : DecidableEq ι]
[inst_1 : AddCommMonoid ι] [inst_2 : CommRing R] [inst_3 : LieRing L] [inst_4 : LieAlgebra R L]
(ℒ : ι → Submodule R L) [inst_5 : GradedLieAlgebra ℒ] [inst_6 : DecidableEq κ] [inst_7 : AddCommGroup M]
[inst_8 : Mod... | 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 |
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 |
_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 |
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 |
List.Nodup.append | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Nodup → l₂.Nodup → l₁.Disjoint l₂ → (l₁ ++ l₂).Nodup | null | true |
_private.Mathlib.Tactic.Linter.Header.0.Mathlib.Linter.initFn._@.Mathlib.Tactic.Linter.Header.677549960._hygCtx._hyg.4 | Mathlib.Tactic.Linter.Header | IO (Lean.Option String) | null | false |
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 |
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.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.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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.