name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Over.closedUnderLimitsOfShape_pullback | Mathlib.CategoryTheory.Limits.MorphismProperty | ∀ {T : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} T] (P : CategoryTheory.MorphismProperty T) {X : T}
[CategoryTheory.Limits.HasPullbacks T] [P.IsStableUnderComposition] [P.IsStableUnderBaseChange]
[P.HasOfPostcompProperty P], P.overObj.IsClosedUnderLimitsOfShape CategoryTheory.Limits.WalkingCospan | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.0.Lean.Meta.Grind.Arith.Cutsat.initFn._@.Lean.Meta.Tactic.Grind.Arith.Cutsat.3902918421._hygCtx._hyg.2 | Lean.Meta.Tactic.Grind.Arith.Cutsat | IO Unit | false |
neg_one_eq_one_iff | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : Ring R] [Nontrivial R], -1 = 1 ↔ ringChar R = 2 | true |
_private.Batteries.Lean.EStateM.0.EStateM.tryCatch.match_1.eq_2 | Batteries.Lean.EStateM | ∀ {ε σ α : Type u_1} (motive : EStateM.Result ε σ α → Sort u_2) (ok : EStateM.Result ε σ α)
(h_1 : (e : ε) → (s : σ) → motive (EStateM.Result.error e s)) (h_2 : (ok : EStateM.Result ε σ α) → motive ok),
(∀ (e : ε) (s : σ), ok = EStateM.Result.error e s → False) →
(match ok with
| EStateM.Result.error e s => h_1 e s
| ok => h_2 ok) =
h_2 ok | true |
Qq.MaybeLevelDefEq.defEq.sizeOf_spec | Qq.MetaM | ∀ {u v : Lean.Level} (a : u =QL v), sizeOf (Qq.MaybeLevelDefEq.defEq a) = 1 + sizeOf a | true |
Equiv.commGroup._proof_5 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommGroup β] (x : α) (n : ℕ), e (e.symm (e x ^ n)) = e x ^ n | false |
sigmaFinsuppEquivDFinsupp_add | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {η : ι → Type u_4} {N : Type u_5} [inst : AddZeroClass N] (f g : (i : ι) × η i →₀ N),
sigmaFinsuppEquivDFinsupp (f + g) = sigmaFinsuppEquivDFinsupp f + sigmaFinsuppEquivDFinsupp g | true |
Lean.Lsp.instOrdLeanDiagnosticTag.ord | Lean.Data.Lsp.Diagnostics | Lean.Lsp.LeanDiagnosticTag → Lean.Lsp.LeanDiagnosticTag → Ordering | true |
_private.Mathlib.Algebra.Order.Archimedean.Class.0.MulArchimedeanOrder.orderHom._simp_3 | Mathlib.Algebra.Order.Archimedean.Class | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | false |
Std.Sat.AIG.RefVec.IfInput.casesOn | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Sat.AIG.RefVec.IfInput aig w → Sort u} →
(t : Std.Sat.AIG.RefVec.IfInput aig w) →
((discr : aig.Ref) → (lhs rhs : aig.RefVec w) → motive { discr := discr, lhs := lhs, rhs := rhs }) →
motive t | false |
_private.Mathlib.Data.ENNReal.Inv.0.ENNReal.mul_inv._proof_1_4 | Mathlib.Data.ENNReal.Inv | ∀ (x x_1 : NNReal), (↑x_1 * ↑x)⁻¹ = (↑x_1)⁻¹ * (↑x)⁻¹ | false |
instDistribLatticePrimeMultiset | Mathlib.Data.PNat.Factors | DistribLattice PrimeMultiset | true |
Set.infinite_div | Mathlib.Algebra.Group.Pointwise.Set.Finite | ∀ {α : Type u_2} [inst : Group α] {s t : Set α}, (s / t).Infinite ↔ s.Infinite ∧ t.Nonempty ∨ t.Infinite ∧ s.Nonempty | true |
CategoryTheory.ObjectProperty.IsClosedUnderIsomorphisms.of_inheritedFromTarget | Mathlib.CategoryTheory.ObjectProperty.InheritedFromHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (P : CategoryTheory.ObjectProperty C)
(Q : CategoryTheory.MorphismProperty C) [P.InheritedFromTarget Q] [Q.RespectsIso] [Q.ContainsIdentities],
P.IsClosedUnderIsomorphisms | true |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_SurjOn._proof_1_1 | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ}, 1 < b → ¬b = 0 | false |
IocProdIoc._proof_2 | Mathlib.Probability.Kernel.IonescuTulcea.Maps | ∀ {ι : Type u_1} [inst : LinearOrder ι] [inst_1 : LocallyFiniteOrder ι] (a b c : ι) (i : ↥(Finset.Ioc a c)),
¬↑i ≤ b → ↑i ∈ Finset.Ioc b c | false |
Prod.instSemilatticeInf._proof_1 | Mathlib.Order.Lattice | ∀ (α : Type u_1) (β : Type u_2) [inst : SemilatticeInf α] [inst_1 : SemilatticeInf β] (x x_1 : α × β),
(x.1 ⊓ x_1.1, x.2 ⊓ x_1.2).1 ≤ x.1 ∧ (x.1 ⊓ x_1.1, x.2 ⊓ x_1.2).2 ≤ x.2 | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.Cutsat.ToIntInfo} →
t = t' → Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.noConfusionType P t t' | false |
_private.Mathlib.CategoryTheory.Functor.Derived.LeftDerived.0.CategoryTheory.Functor.isLeftDerivedFunctor_iff_of_iso._simp_1_1 | Mathlib.CategoryTheory.Functor.Derived.LeftDerived | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_3, u_2} D] [inst_2 : CategoryTheory.Category.{v_5, u_3} H]
(LF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : L.comp LF ⟶ F) (W : CategoryTheory.MorphismProperty C) [inst_3 : L.IsLocalization W],
LF.IsLeftDerivedFunctor α W = LF.IsRightKanExtension α | false |
_private.Mathlib.Algebra.Module.Submodule.Bilinear.0.Submodule.map₂_span_span._simp_1_2 | Mathlib.Algebra.Module.Submodule.Bilinear | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] {module_M : Module R M} (p : Submodule R M)
{x : M} (r : R), x ∈ p → (r • x ∈ p) = True | false |
WithAbs.instAlgebra._proof_5 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] {R : Type u_3} {T : Type u_1} [inst_2 : CommSemiring R]
[inst_3 : Semiring T] [inst_4 : Algebra R T] (v : AbsoluteValue T S),
(↑↑((RingEquiv.symm (WithAbs.equiv v).ringEquiv).toRingHom.comp (algebraMap R T))).toFun 0 = 0 | false |
Lean.Meta.LazyDiscrTree.findImportMatches | Lean.Meta.LazyDiscrTree | {α : Type} →
Lean.EnvExtension (IO.Ref (Option (Lean.Meta.LazyDiscrTree α))) →
(Lean.Name → Lean.ConstantInfo → Lean.MetaM (Array (Lean.Meta.LazyDiscrTree.InitEntry α))) →
optParam (List (List Lean.Meta.LazyDiscrTree.Key)) [] →
optParam ℕ 1000 →
optParam (Option (IO.Ref (Option (Array α)))) none →
Lean.Expr → Lean.MetaM (Lean.Meta.LazyDiscrTree.MatchResult α) | true |
_private.Batteries.Data.List.Lemmas.0.List.nodup_findIdxs._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {a b : ℕ}, a < b → ¬a = b | false |
Std.Time.Day.instInhabitedOffset | Std.Time.Date.Unit.Day | Inhabited Std.Time.Day.Offset | true |
ULift.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {α : Type u_1} → [MeasurableSpace α] → MeasurableSpace (ULift.{u_6, u_1} α) | true |
Lean.Server.ReferencedObject.recOn | Lean.Server.Rpc.Basic | {motive : Lean.Server.ReferencedObject → Sort u} →
(t : Lean.Server.ReferencedObject) →
((obj : Dynamic) → (id : USize) → (rc : ℕ) → motive { obj := obj, id := id, rc := rc }) → motive t | false |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxi.Iterator.instIteratorLoop.loop.wf._unary | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
[inst : Std.PRange.UpwardEnumerable α] →
[Std.PRange.LawfulUpwardEnumerable α] →
{n : Type u → Type w} →
[Monad n] →
(γ : Type u) →
(Pl : α → γ → ForInStep γ → Prop) →
Std.IteratorLoop.WellFounded (Std.Rxi.Iterator α) Id Pl →
(LargeEnough : α → Prop) →
(∀ (a b : α), Std.PRange.UpwardEnumerable.LE a b → LargeEnough a → LargeEnough b) →
((out : α) → LargeEnough out → (c : γ) → n { s // Pl out c s }) →
(_ : γ) ×' (next : α) ×' LargeEnough next → n γ | false |
GradedMonoid.GradeZero.smul | Mathlib.Algebra.GradedMonoid | {ι : Type u_1} → (A : ι → Type u_2) → [inst : AddZeroClass ι] → [GradedMonoid.GMul A] → (i : ι) → SMul (A 0) (A i) | true |
ContextFreeGrammar.generates_reverse | Mathlib.Computability.ContextFreeGrammar | ∀ {T : Type u_1} {g : ContextFreeGrammar T} {u : List (Symbol T g.NT)}, g.reverse.Generates u.reverse ↔ g.Generates u | true |
MeasurableConstVAdd.recOn | Mathlib.MeasureTheory.Group.Arithmetic | {M : Type u_2} →
{α : Type u_3} →
[inst : VAdd M α] →
[inst_1 : MeasurableSpace α] →
{motive : MeasurableConstVAdd M α → Sort u} →
(t : MeasurableConstVAdd M α) →
((measurable_const_vadd : ∀ (c : M), Measurable fun x => c +ᵥ x) → motive ⋯) → motive t | false |
not_isSquare_of_neg | Mathlib.Algebra.Order.Ring.Basic | ∀ {R : Type u_3} [inst : Semiring R] [inst_1 : LinearOrder R] [ExistsAddOfLE R] [PosMulMono R] [AddLeftMono R] {x : R},
x < 0 → ¬IsSquare x | true |
LinearMap.isPairSelfAdjointSubmodule | Mathlib.LinearAlgebra.SesquilinearForm.Basic | {R : Type u_1} →
{M : Type u_5} →
{M₂ : Type u_7} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup M₂] →
[inst_4 : Module R M₂] → (M →ₗ[R] M →ₗ[R] M₂) → (M →ₗ[R] M →ₗ[R] M₂) → Submodule R (Module.End R M) | true |
CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.isCardinalFiltered | Mathlib.CategoryTheory.Presentable.Directed | ∀ (J : Type w) [inst : CategoryTheory.SmallCategory J] (κ : Cardinal.{w}) [inst_1 : Fact κ.IsRegular]
[CategoryTheory.IsCardinalFiltered J κ],
(∀ (e : J), ∃ m x, IsEmpty (m ⟶ e)) →
CategoryTheory.IsCardinalFiltered
(CategoryTheory.IsCardinalFiltered.exists_cardinal_directed.DiagramWithUniqueTerminal J κ) κ | true |
Real.instNormedAddCommGroupAngle._aux_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle → Real.Angle → Real.Angle | false |
_private.Mathlib.Data.List.Sigma.0.List.sublist_dlookup._proof_1_1 | Mathlib.Data.List.Sigma | ∀ {α : Type u_2} {β : α → Type u_1} [inst : DecidableEq α] {l₁ l₂ : List (Sigma β)} {a : α} {b : β a},
l₂.NodupKeys → l₁.Sublist l₂ → b ∈ List.dlookup a l₁ → b ∈ List.dlookup a l₂ | false |
isConnected_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : ConditionallyCompleteLinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] {a b : α}, a ≤ b → IsConnected (Set.Icc a b) | true |
ValuativeRel.RankLeOneStruct.mk._flat_ctor | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : CommRing R] →
[inst_1 : ValuativeRel R] →
(emb : ValuativeRel.ValueGroupWithZero R →*₀ NNReal) → StrictMono ⇑emb → ValuativeRel.RankLeOneStruct R | false |
Aesop.GlobalRuleSet.modifyBaseM | Aesop.RuleSet | {m : Type → Type u_1} →
[Monad m] → (Aesop.BaseRuleSet → m Aesop.BaseRuleSet) → Aesop.GlobalRuleSet → m Aesop.GlobalRuleSet | true |
Submodule.orthogonalProjection_apply_eq_linearProjOfIsCompl | Mathlib.Analysis.InnerProductSpace.Projection.Submodule | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] (x : E),
K.orthogonalProjection x = (K.linearProjOfIsCompl Kᗮ ⋯) x | true |
CFC.log_monotoneOn | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.ExpLog.Order | ∀ {A : Type u_1} [inst : CStarAlgebra A] [inst_1 : PartialOrder A] [StarOrderedRing A],
MonotoneOn CFC.log {a | IsStrictlyPositive a} | true |
Polynomial.Chebyshev.aeval_S | Mathlib.RingTheory.Polynomial.Chebyshev | ∀ {R : Type u_1} {R' : Type u_2} [inst : CommRing R] [inst_1 : CommRing R'] [inst_2 : Algebra R R'] (x : R') (n : ℤ),
(Polynomial.aeval x) (Polynomial.Chebyshev.S R n) = Polynomial.eval x (Polynomial.Chebyshev.S R' n) | true |
toWeakSpaceCLM_bijective | Mathlib.Topology.Algebra.Module.WeakDual | ∀ {𝕜 : Type u_2} {E : Type u_4} [inst : CommSemiring 𝕜] [inst_1 : TopologicalSpace 𝕜] [inst_2 : ContinuousAdd 𝕜]
[inst_3 : ContinuousConstSMul 𝕜 𝕜] [inst_4 : AddCommMonoid E] [inst_5 : Module 𝕜 E] [inst_6 : TopologicalSpace E],
Function.Bijective ⇑(toWeakSpaceCLM 𝕜 E) | true |
UnivLE.succ | Mathlib.Logic.UnivLE | ∀ [UnivLE.{u, v}], UnivLE.{u, v + 1} | true |
CategoryTheory.Triangulated.TStructure.triangleω₁δ_map_hom₃ | Mathlib.CategoryTheory.Triangulated.TStructure.SpectralObject | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.Triangulated.TStructure C) [inst_6 : CategoryTheory.IsTriangulated C] (a b c : EInt) (hab : a ≤ b)
(hbc : b ≤ c) {X Y : C} (φ : X ⟶ Y),
((t.triangleω₁δ a b c hab hbc).map φ).hom₃ = (t.eTruncGE.obj b).map ((t.eTruncLT.obj c).map φ) | true |
LibraryNote.«reducible_non-instances» | Mathlib.Algebra.HierarchyDesign | Batteries.Util.LibraryNote | true |
_private.Lean.Compiler.FFI.0.Lean.Compiler.FFI.flagsStringToArray | Lean.Compiler.FFI | String → Array String | true |
BitVec.toNat_cpop_append | Init.Data.BitVec.Lemmas | ∀ {w u : ℕ} {x : BitVec w} {y : BitVec u}, (x ++ y).cpop.toNat = x.cpop.toNat + y.cpop.toNat | true |
MeasureTheory.Lp.norm_measure_zero | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {α : Type u_1} {E : Type u_4} {m : MeasurableSpace α} {p : ENNReal} [inst : NormedAddCommGroup E]
(f : ↥(MeasureTheory.Lp E p 0)), ‖f‖ = 0 | true |
Lean.Meta.typeFormerTypeLevelQuick._unsafe_rec | Lean.Meta.InferType | Lean.Expr → Option Lean.Level | false |
String.utf8EncodeChar_eq_utf8EncodeCharFast | Init.Data.String.Decode | String.utf8EncodeChar = String.utf8EncodeCharFast | true |
_private.Batteries.Data.Array.Scan.0.Array.size_scanl._proof_1_1 | Batteries.Data.Array.Scan | ∀ {β : Type u_1} {α : Type u_2} {f : β → α → β} (init : β) (as : Array α), (Array.scanl f init as).size = as.size + 1 | false |
Relation.ReflGen.recOn | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {r : α → α → Prop} {a : α} {motive : (a_1 : α) → Relation.ReflGen r a a_1 → Prop} {a_1 : α}
(t : Relation.ReflGen r a a_1), motive a ⋯ → (∀ {b : α} (a_2 : r a b), motive b ⋯) → motive a_1 t | false |
IsDiscreteValuationRing.addVal.eq_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ (R : Type u) [inst : CommRing R] [inst_1 : IsDomain R] [inst_2 : IsDiscreteValuationRing R],
IsDiscreteValuationRing.addVal R = multiplicity_addValuation ⋯ | true |
CategoryTheory.Limits.comp_preservesColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : Type w} [inst_2 : CategoryTheory.Category.{w', w} J] {E : Type u₃} [ℰ : CategoryTheory.Category.{v₃, u₃} E]
(F : CategoryTheory.Functor C D) (G : CategoryTheory.Functor D E) [CategoryTheory.Limits.PreservesColimitsOfShape J F]
[CategoryTheory.Limits.PreservesColimitsOfShape J G], CategoryTheory.Limits.PreservesColimitsOfShape J (F.comp G) | true |
Lean.Meta.ExtractLetsConfig.lift._default | Init.MetaTypes | Bool | false |
CategoryTheory.Equivalence.rightOp_unitIso_inv_app | Mathlib.CategoryTheory.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(e : Cᵒᵖ ≌ D) (X : C), e.rightOp.unitIso.inv.app X = (e.unitIso.hom.app (Opposite.op X)).unop | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.Decl.isCasesOnParam?.go | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.Decl pu → {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Code pu → Option ℕ | true |
OrthonormalBasis.mulOpposite | Mathlib.Analysis.InnerProductSpace.MulOpposite | {𝕜 : Type u_1} →
[inst : RCLike 𝕜] →
{ι : Type u_3} →
{H : Type u_4} →
[inst_1 : NormedAddCommGroup H] →
[inst_2 : InnerProductSpace 𝕜 H] → [inst_3 : Fintype ι] → OrthonormalBasis ι 𝕜 H → OrthonormalBasis ι 𝕜 Hᵐᵒᵖ | true |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.substVar._sparseCasesOn_1 | Lean.Meta.Tactic.Subst | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
AddMonoidAlgebra.instBialgebra | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | (R : Type u_1) →
(A : Type u_2) →
(M : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [Bialgebra R A] → [inst_3 : AddMonoid M] → Bialgebra R (AddMonoidAlgebra A M) | true |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE_X₃ | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ n₂ : ℤ)
(hn₁ : autoParam (n₀ + 1 = n₁) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE._auto_1)
(hn₂ : autoParam (n₁ + 1 = n₂) CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcyclesE._auto_3),
(X.kernelSequenceOpcyclesE f₁ f₂ f₃ n₀ n₁ n₂ hn₁ hn₂).X₃ = (X.H n₂).obj (CategoryTheory.ComposableArrows.mk₁ f₁) | true |
Measurable.setOf | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, Measurable p → MeasurableSet {a | p a} | true |
Lean.Lsp.instFromJsonTextDocumentPositionParams.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.TextDocumentPositionParams | true |
jacobiSum | Mathlib.NumberTheory.JacobiSum.Basic | {R : Type u_1} →
{R' : Type u_2} → [inst : CommRing R] → [Fintype R] → [inst_2 : CommRing R'] → MulChar R R' → MulChar R R' → R' | true |
_private.Mathlib.CategoryTheory.EffectiveEpi.Preserves.0.CategoryTheory.effectiveEpiFamilyStructOfEquivalence_aux._simp_1_1 | Mathlib.CategoryTheory.EffectiveEpi.Preserves | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | false |
Path.Homotopy.reflTransSymmAux._proof_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | (1 + 1).AtLeastTwo | false |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.uIoc_injective_right._simp_1_2 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (b < a) = ¬a ≤ b | false |
ValuationSubring.instFieldSubtypeMemTop._proof_16 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (x x_1 : ↥⊤), ↑(x + x_1) = ↑(x + x_1) | false |
Lean.Elab.Term.ToDepElimPattern.Context.explicitPatternVars | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.Context → Array Lean.FVarId | true |
Metric.hausdorffEDist | Mathlib.Topology.MetricSpace.HausdorffDistance | {α : Type u_2} → [PseudoEMetricSpace α] → Set α → Set α → ENNReal | true |
CategoryTheory.Limits.equalizer.ι_of_eq | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f g : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
f = g → CategoryTheory.IsIso (CategoryTheory.Limits.equalizer.ι f g) | true |
_private.Std.Data.DHashMap.Internal.AssocList.Lemmas.0.Std.DHashMap.Internal.AssocList.filter.eq_1 | Std.Data.DHashMap.Internal.AssocList.Lemmas | ∀ {α : Type u} {β : α → Type v} (f : (a : α) → β a → Bool),
Std.DHashMap.Internal.AssocList.filter f =
Std.DHashMap.Internal.AssocList.filter.go✝ f Std.DHashMap.Internal.AssocList.nil | true |
HomologicalComplex₂.instHasTotalFlip_1 | Mathlib.Algebra.Homology.TotalComplexSymmetry | ∀ {C : Type u_1} {I₁ : Type u_2} {I₂ : Type u_3} {J : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Preadditive C] {c₁ : ComplexShape I₁} {c₂ : ComplexShape I₂}
(K : HomologicalComplex₂ C c₁ c₂) (c : ComplexShape J) [inst_2 : TotalComplexShape c₁ c₂ c] [K.HasTotal c],
K.flip.flip.HasTotal c | true |
_private.Mathlib.Algebra.Group.Pointwise.Set.BigOperators.0.Set.mem_finset_prod._simp_1_1 | Mathlib.Algebra.Group.Pointwise.Set.BigOperators | ∀ {α : Type u_2} [inst : One α] {a : α}, (a ∈ 1) = (a = 1) | false |
PseudoEMetricSpace.ofEDistOfTopology | Mathlib.Topology.EMetricSpace.Defs | {α : Type u_2} →
[inst : TopologicalSpace α] →
(d : α → α → ENNReal) →
(∀ (x : α), d x x = 0) →
(∀ (x y : α), d x y = d y x) →
(∀ (x y z : α), d x z ≤ d x y + d y z) →
(∀ (x : α), (nhds x).HasBasis (fun c => 0 < c) fun c => {y | d x y < c}) → PseudoEMetricSpace α | true |
Std.Sat.AIG.mk.noConfusion | Std.Sat.AIG.Basic | {α : Type} →
{inst : DecidableEq α} →
{inst_1 : Hashable α} →
{P : Sort u} →
{decls : Array (Std.Sat.AIG.Decl α)} →
{cache : Std.Sat.AIG.Cache α decls} →
{hdag : Std.Sat.AIG.IsDAG α decls} →
{hzero : 0 < decls.size} →
{hconst : decls[0] = Std.Sat.AIG.Decl.false} →
{decls' : Array (Std.Sat.AIG.Decl α)} →
{cache' : Std.Sat.AIG.Cache α decls'} →
{hdag' : Std.Sat.AIG.IsDAG α decls'} →
{hzero' : 0 < decls'.size} →
{hconst' : decls'[0] = Std.Sat.AIG.Decl.false} →
{ decls := decls, cache := cache, hdag := hdag, hzero := hzero, hconst := hconst } =
{ decls := decls', cache := cache', hdag := hdag', hzero := hzero',
hconst := hconst' } →
(decls ≍ decls' → cache ≍ cache' → P) → P | false |
WithBot.toDual_apply_bot | Mathlib.Order.WithBot | ∀ {α : Type u_1}, WithBot.toDual ⊥ = ⊤ | true |
BoolRing.instConcreteCategoryRingHomCarrier._proof_4 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y Z : BoolRing} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↑X),
(CategoryTheory.CategoryStruct.comp f g).hom' x = g.hom' (f.hom' x) | false |
Std.Time.Weekday.instDecidableLeOrdinal | Std.Time.Date.Unit.Weekday | {x y : Std.Time.Weekday.Ordinal} → Decidable (x ≤ y) | true |
CategoryTheory.Presheaf.instIsLocallyInjectiveOfIsIsoFunctorOpposite | Mathlib.CategoryTheory.Sites.LocallyInjective | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
{FD : D → D → Type u_1} {CD : D → Type w} [inst_2 : (X Y : D) → FunLike (FD X Y) (CD X) (CD Y)]
[inst_3 : CategoryTheory.ConcreteCategory D FD] (J : CategoryTheory.GrothendieckTopology C)
{F₁ F₂ : CategoryTheory.Functor Cᵒᵖ D} (φ : F₁ ⟶ F₂) [CategoryTheory.IsIso φ],
CategoryTheory.Presheaf.IsLocallyInjective J φ | true |
CategoryTheory.ShortComplex.moduleCatCyclesIso_inv_iCycles_assoc_apply | Mathlib.Algebra.Homology.ShortComplex.ModuleCat | ∀ {R : Type u} [inst : Ring R] (S : CategoryTheory.ShortComplex (ModuleCat R)) {Z : ModuleCat R} (h : S.X₂ ⟶ Z)
(x : ↑S.moduleCatLeftHomologyData.K),
(CategoryTheory.ConcreteCategory.hom h)
((CategoryTheory.ConcreteCategory.hom S.iCycles)
((CategoryTheory.ConcreteCategory.hom S.moduleCatCyclesIso.inv) x)) =
(CategoryTheory.ConcreteCategory.hom h) ((ModuleCat.Hom.hom S.g).ker.subtype x) | true |
String.Legacy.Iterator.ValidFor.casesOn | Batteries.Data.String.Lemmas | {l r : List Char} →
{motive : (a : String.Legacy.Iterator) → String.Legacy.Iterator.ValidFor l r a → Sort u} →
{a : String.Legacy.Iterator} →
(t : String.Legacy.Iterator.ValidFor l r a) →
motive { s := String.ofList (l.reverseAux r), i := { byteIdx := String.utf8Len l } } ⋯ → motive a t | false |
Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.Cutsat.EqCnstr | Sort u → Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State → Lean.Meta.Grind.Arith.Cutsat.PropagateMul.State → Sort u | false |
Lean.Meta.Sym.State.share._default | Lean.Meta.Sym.SymM | Lean.Meta.Sym.AlphaShareCommon.State | false |
Std.LawfulBEqCmp.compare_eq_iff_beq | Init.Data.Order.Ord | ∀ {α : Type u} {inst : BEq α} {cmp : α → α → Ordering} [self : Std.LawfulBEqCmp cmp] {a b : α},
cmp a b = Ordering.eq ↔ (a == b) = true | true |
_private.Lean.Compiler.LCNF.CompilerM.0.Lean.Compiler.LCNF.normArgImp.match_3 | Lean.Compiler.LCNF.CompilerM | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Arg pu → Sort u_1) →
(arg : Lean.Compiler.LCNF.Arg pu) →
(Unit → motive Lean.Compiler.LCNF.Arg.erased) →
((fvarId : Lean.FVarId) → motive (Lean.Compiler.LCNF.Arg.fvar fvarId)) →
((e : Lean.Expr) → (h : pu = Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.Arg.type e h)) →
motive arg | false |
_private.Mathlib.FieldTheory.PerfectClosure.0.PerfectClosure.mul_aux_right.match_1_1 | Mathlib.FieldTheory.PerfectClosure | ∀ (K : Type u_1) [inst : CommRing K] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p]
(motive : (y1 y2 : ℕ × K) → PerfectClosure.R K p y1 y2 → Prop) (y1 y2 : ℕ × K) (H : PerfectClosure.R K p y1 y2),
(∀ (n : ℕ) (y : K), motive (n, y) (n + 1, (frobenius K p) y) ⋯) → motive y1 y2 H | false |
LinearMap.concaveOn | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [inst_5 : Module 𝕜 E] [inst_6 : Module 𝕜 β] (f : E →ₗ[𝕜] β)
{s : Set E}, Convex 𝕜 s → ConcaveOn 𝕜 s ⇑f | true |
Fin.natAdd_castLEEmb_apply_val | Mathlib.Data.Fin.Embedding | ∀ {n m : ℕ} (hmn : n ≤ m) (a : Fin n), ↑((Fin.natAdd_castLEEmb hmn) a) = ↑a + (m - n) | true |
Lean.Server.statefulRequestHandlers | Lean.Server.Requests | IO.Ref (Lean.PersistentHashMap String Lean.Server.StatefulRequestHandler) | true |
AddConstEquiv.symm_refl | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} [inst : Add G] (a : G), (AddConstEquiv.refl a).symm = AddConstEquiv.refl a | true |
Lean.Parser.Attr.sevalprocBuiltinAttr | Init.Simproc | Lean.ParserDescr | true |
zpow_mul' | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : DivisionMonoid α] (a : α) (m n : ℤ), a ^ (m * n) = (a ^ n) ^ m | true |
Std.Iterators.Types.Empty.noConfusion | Std.Data.Iterators.Producers.Monadic.Empty | {P : Sort u} →
{m : Type w → Type w'} →
{β : Type w} →
{t : Std.Iterators.Types.Empty m β} →
{m' : Type w → Type w'} →
{β' : Type w} →
{t' : Std.Iterators.Types.Empty m' β'} →
m = m' → β = β' → t ≍ t' → Std.Iterators.Types.Empty.noConfusionType P t t' | false |
Int.neg_modEq_neg | Mathlib.Data.Int.ModEq | ∀ {n a b : ℤ}, -a ≡ -b [ZMOD n] ↔ a ≡ b [ZMOD n] | true |
CategoryTheory.Limits.Cone.toStructuredArrowCompToUnderCompForget_inv_app | Mathlib.CategoryTheory.Limits.ConeCategory | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor J C} (c : CategoryTheory.Limits.Cone F) (X : J),
c.toStructuredArrowCompToUnderCompForget.inv.app X = CategoryTheory.CategoryStruct.id (F.obj X) | true |
Lean.Grind.CommRing.Poly.cancelVar'._sunfold | Init.Grind.Ring.CommSolver | ℤ → Lean.Grind.CommRing.Var → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly → Lean.Grind.CommRing.Poly | false |
AddEquiv.toMultiplicativeLeft_apply_apply | Mathlib.Algebra.Group.Equiv.TypeTags | ∀ {G : Type u_2} {H : Type u_3} [inst : AddZeroClass G] [inst_1 : MulOneClass H] (f : G ≃+ Additive H)
(a : Multiplicative G), (AddEquiv.toMultiplicativeLeft f) a = (AddMonoidHom.toMultiplicativeLeft f.toAddMonoidHom) a | true |
Finset.mem_addSpan._simp_1 | Mathlib.Combinatorics.Additive.Dissociation | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : DecidableEq α] [inst_2 : Fintype α] {s : Finset α} {a : α},
(a ∈ s.addSpan) = ∃ ε, (∀ (a : α), ε a = -1 ∨ ε a = 0 ∨ ε a = 1) ∧ ∑ a ∈ s, ε a • a = a | false |
_private.Mathlib.CategoryTheory.Abelian.Projective.Dimension.0.CategoryTheory.instHasProjectiveDimensionLTHAddNat._proof_1 | Mathlib.CategoryTheory.Abelian.Projective.Dimension | ∀ (n k : ℕ), n ≤ n + k | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.