name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Function.locallyFinsuppWithin.instAddGroup._proof_4 | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {U : Set X} {Y : Type u_2} [inst_1 : AddGroup Y]
(D : Function.locallyFinsuppWithin U Y) (n : ℕ), ⇑(n • D) = n • ⇑D | false |
CategoryTheory.Abelian.Ext.preadditiveYoneda_homologySequenceδ_singleTriangle_apply._proof_2 | Mathlib.Algebra.Homology.DerivedCategory.Ext.ExactSequences | ∀ {n₀ n₁ : ℕ}, 1 + n₀ = n₁ → ↑n₀ + 1 = ↑n₁ | false |
Module.Flat.rTensor_exact | Mathlib.RingTheory.Flat.Basic | ∀ {R : Type u} (M : Type v) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
⦃N : Type u_1⦄ ⦃N' : Type u_2⦄ ⦃N'' : Type u_3⦄ [inst_4 : AddCommGroup N] [inst_5 : AddCommGroup N']
[inst_6 : AddCommGroup N''] [inst_7 : Module R N] [inst_8 : Module R N'] [inst_9 : Module R N''] ⦃f :... | true |
WeierstrassCurve.Jacobian.negAddY._proof_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Formula | (2 + 1).AtLeastTwo | false |
Std.DTreeMap.Raw.alter | Std.Data.DTreeMap.Raw.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.LawfulEqCmp cmp] →
Std.DTreeMap.Raw α β cmp → (a : α) → (Option (β a) → Option (β a)) → Std.DTreeMap.Raw α β cmp | true |
_private.Lean.Meta.Tactic.Generalize.0.Lean.Meta.generalizeCore | Lean.Meta.Tactic.Generalize | Lean.MVarId → Array Lean.Meta.GeneralizeArg → Lean.Meta.TransparencyMode → Lean.MetaM (Array Lean.FVarId × Lean.MVarId) | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.support_gaussianPDF._simp_1_1 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u} (x : α), (x ∈ Set.univ) = True | false |
IsMin.eq_of_ge | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : PartialOrder α] {a b : α}, IsMin a → b ≤ a → a = b | true |
DifferentiableOn.congr | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {s : Set E},
DifferentiableOn 𝕜 f s → (∀ x ∈ s, f₁ x = f... | true |
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) | 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 | 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 | 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₁... | true |
Equiv.Perm.SameCycle.equivalence | Mathlib.GroupTheory.Perm.Cycle.Basic | ∀ {α : Type u_2} (f : Equiv.Perm α), Equivalence f.SameCycle | 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... | true |
_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 | 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... | 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... | 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.equivToOverUnit C).unit.app
((CategoryTheory.toOver (CategoryTheory... | 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 | 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 | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reduceBNe.declare_74._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.904556020._hygCtx._hyg.20 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | false |
Fintype.decidableEqEmbeddingFintype._proof_1 | Mathlib.Data.Fintype.Defs | ∀ {α : Type u_1} {β : Type u_2} (a b : α ↪ β), ⇑a = ⇑b ↔ a = b | 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... | 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 :... | 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 | true |
BitVec.instCommutativeHOr | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, Std.Commutative fun x y => x ||| y | true |
Subgroup.commensurable_strictPeriods_periods | Mathlib.NumberTheory.ModularForms.Cusps | ∀ {R : Type u_1} [inst : Ring R] (𝒢 : Subgroup (GL (Fin 2) R)), 𝒢.strictPeriods.Commensurable 𝒢.periods | 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 | false |
FP.emin.eq_1 | Mathlib.Data.FP.Basic | ∀ [C : FP.FloatCfg], FP.emin = 1 - ↑FP.FloatCfg.emax | 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 | 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 | true |
Function.Embedding.coeWithTop_apply | Mathlib.Order.Hom.WithTopBot | ∀ {α : Type u_1} (a : α), Function.Embedding.coeWithTop a = ↑a | 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 | true |
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 :
... | true |
isClosed_setOf_isCompactOperator | Mathlib.Analysis.Normed.Operator.Compact | ∀ {𝕜₁ : 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... | true |
Nat.lt_irrefl | Init.Prelude | ∀ (n : ℕ), ¬n < n | true |
Fin.sub_eq_add_neg | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (x y : Fin n), x - y = x + -y | true |
_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 | false |
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.... | 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 ... | true |
Std.TreeMap.foldl | Std.Data.TreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {δ : Type w} → (δ → α → β → δ) → δ → Std.TreeMap α β cmp → δ | 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 | 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) | 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 | true |
Aesop.ForwardRuleMatches.eraseHyps | Aesop.Tree.Data.ForwardRuleMatches | Std.HashSet Lean.FVarId → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches | true |
List.IsSuffix.isInfix | Init.Data.List.Sublist | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁ <:+ l₂ → l₁ <:+: l₂ | 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 | false |
FP.FloatCfg.mk | Mathlib.Data.FP.Basic | (prec emax : ℕ) → 0 < prec → prec ≤ emax → FP.FloatCfg | true |
CategoryTheory.Functor.mem_inducedTopology_sieves_iff._simp_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.InducedTopology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (G : CategoryTheory.Functor C D)
(K : CategoryTheory.GrothendieckTopology D) [inst_2 : G.LocallyCoverDense K] [inst_3 : G.IsLocallyFull K]
[inst_4 : G.IsLocallyFaithful K] {X : C} (S : Cat... | false |
_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 | false |
CategoryTheory.Classifier.SubobjectRepresentableBy.uniq | Mathlib.CategoryTheory.Topos.Classifier | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasPullbacks C] {Ω : C}
(h : CategoryTheory.Classifier.SubobjectRepresentableBy Ω) {U X : C} {m : U ⟶ X} [inst_2 : CategoryTheory.Mono m]
{χ' : X ⟶ Ω} {π : U ⟶ CategoryTheory.Subobject.underlying.obj h.Ω₀},
CategoryTheory.IsP... | true |
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]! | true |
Lean.MetavarContext.MkBindingM.Context.ctorIdx | Lean.MetavarContext | Lean.MetavarContext.MkBindingM.Context → ℕ | false |
RelIso.apply_faithfulSMul | Mathlib.Algebra.Order.Group.Action.End | ∀ {α : Type u_1} {r : α → α → Prop}, FaithfulSMul (r ≃r r) α | true |
ClusterPt | Mathlib.Topology.Defs.Filter | {X : Type u_1} → [TopologicalSpace X] → X → Filter X → Prop | 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... | 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 | 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) | true |
Lean.Elab.PartialFixpointType.inductiveFixpoint | Lean.Elab.PreDefinition.TerminationHint | Lean.Elab.PartialFixpointType | 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 | true |
Lean.Widget.HighlightedSubexprInfo.highlighted.sizeOf_spec | Lean.Server.FileWorker.WidgetRequests | sizeOf Lean.Widget.HighlightedSubexprInfo.highlighted = 1 | 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₂... | 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) | 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 | 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) | 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 [] | 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 | 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 | true |
CauchyFilter.mem_uniformity | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, CauchyFilter.gen t ⊆ s | 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 | true |
Matroid.isNonloop_of_not_isLoop._auto_1 | Mathlib.Combinatorics.Matroid.Loop | Lean.Syntax | 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 | true |
Lean.Elab.Tactic.nonempty_prop_to_inhabited | Mathlib.Tactic.Inhabit | (α : Prop) → Nonempty α → Inhabited α | true |
Order.pred_covBy | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : PredOrder α] [NoMinOrder α] (a : α), Order.pred a ⋖ a | 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 | 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] →
... | 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 | false |
Lean.Grind.AC.Seq.subseq | Lean.Meta.Tactic.Grind.AC.Seq | Lean.Grind.AC.Seq → Lean.Grind.AC.Seq → Lean.Grind.AC.SubseqResult | true |
Order.Ioc_pred_left | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] [NoMinOrder α] (a b : α),
Set.Ioc (Order.pred a) b = Set.Icc a b | true |
Std.ExtTreeMap.getEntryGED | Std.Data.ExtTreeMap.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → [Std.TransCmp cmp] → Std.ExtTreeMap α β cmp → α → α × β → α × β | 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} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | false |
Mathlib.Tactic.LibraryRewrite.RewriteInterface.tactic | Mathlib.Tactic.Widget.LibraryRewrite | Mathlib.Tactic.LibraryRewrite.RewriteInterface → String | true |
of_isDiscreteValuationRing | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ (A : Type u) [inst : CommRing A] [inst_1 : IsDomain A] [IsDiscreteValuationRing A], ValuationRing A | true |
and_congr_left' | Init.PropLemmas | ∀ {a b c : Prop}, (a ↔ b) → (a ∧ c ↔ b ∧ c) | true |
Lean.Lsp.instToJsonDeclarationParams.toJson | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.DeclarationParams → Lean.Json | true |
List.Nodup.append | Mathlib.Data.List.Nodup | ∀ {α : Type u} {l₁ l₂ : List α}, l₁.Nodup → l₂.Nodup → l₁.Disjoint l₂ → (l₁ ++ l₂).Nodup | true |
Lean.Grind.CommRing.eq_normS_cert | Init.Grind.Ring.CommSemiringAdapter | Lean.Grind.CommRing.Expr → Lean.Grind.CommRing.Expr → Bool | 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 | 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 | 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') | true |
_private.Mathlib.Topology.MetricSpace.HausdorffDistance.0.Metric.infEDist_le_infEDist_add_hausdorffEDist._simp_1_1 | Mathlib.Topology.MetricSpace.HausdorffDistance | ∀ {α : Type u} [inst : AddZeroClass α] [inst_1 : PartialOrder α] [CanonicallyOrderedAdd α] {a : α}, (0 < a) = (a ≠ 0) | 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 | 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 | 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 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
(match 0 with
| 0 => h_1 ()
| k.succ => h_2 k) =
h_1 () | 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... | 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 | 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 | 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) | true |
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 | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.