name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.seqToCode.go.match_3.splitter | Lean.Compiler.LCNF.ToLCNF | (motive : Lean.Compiler.LCNF.ToLCNF.Element✝ → Sort u_1) →
(x : Lean.Compiler.LCNF.ToLCNF.Element✝) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
motive (Lean.Compiler.LCNF.ToLCNF.Element.jp✝ decl)) →
((decl : Lean.Compiler.LCNF.FunDecl Lean.Compiler.LCNF.Purity.pure) →
... | null | true |
Lean.Elab.Do.ForwardArg.body | Lean.Elab.Do.ForwardSyntax | Lean.Elab.Do.ForwardArg → Lean.DoSeq | null | true |
_private.Mathlib.GroupTheory.GroupAction.Jordan.0.MulAction.IsPreprimitive.is_two_motive_of_is_motive._simp_1_3 | Mathlib.GroupTheory.GroupAction.Jordan | ∀ {α : Type u_1} {s : Set α}, (s.ncard = 1) = ∃ a, s = {a} | null | false |
Nat.toArray_rio_eq_singleton_append_iff | Init.Data.Range.Polymorphic.NatLemmas | ∀ {xs : Array ℕ} {n a : ℕ}, (*...n).toArray = #[a] ++ xs ↔ 0 = a ∧ 0 < n ∧ (1...n).toArray = xs | null | true |
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 | Let `P` be stable under composition and base change. If `P` satisfies cancellation on the right,
the subcategory of `Over X` defined by `P` is closed under pullbacks.
Without the cancellation property, this does not in general. Consider for example
`P = Function.Surjective` on `Type`. | true |
neg_one_eq_one_iff | Mathlib.Algebra.CharP.Two | ∀ {R : Type u_1} [inst : NonAssocRing R] [Nontrivial R], -1 = 1 ↔ ringChar R = 2 | null | 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 ... | null | true |
Qq.MaybeLevelDefEq.defEq.sizeOf_spec | Qq.MetaM | ∀ {u v : Lean.Level} (a : u =QL v), sizeOf (Qq.MaybeLevelDefEq.defEq a) = 1 + sizeOf a | null | true |
Equiv.commGroup._proof_5 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CommGroup β] (x : α) (n : ℕ),
e (e.symm (e.toFun x ^ n)) = e.toFun x ^ n | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.0.UInt64.reduceNe._regBuiltin.UInt64.reduceNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt.869070958._hygCtx._hyg.9 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.UInt | IO Unit | null | 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 | null | true |
Lean.Lsp.instOrdLeanDiagnosticTag.ord | Lean.Data.Lsp.Diagnostics | Lean.Lsp.LeanDiagnosticTag → Lean.Lsp.LeanDiagnosticTag → Ordering | null | true |
_private.Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique.0.AlgebraNorm.instFieldCopy._aux_32 | Mathlib.Analysis.Normed.Unbundled.IsPowMulUnique | {K : Type u_1} →
{L : Type u_2} →
[inst : NontriviallyNormedField K] →
[inst_1 : Field L] →
[inst_2 : Algebra K L] → (_f : AlgebraNorm K L) → (x : L) → AlgebraNorm.copy✝ _f x → AlgebraNorm.copy✝ _f x | null | false |
_private.Mathlib.RingTheory.HopkinsLevitzki.0.IsSemiprimaryRing.finite_of_isNoetherian_or_isArtinian._proof_1_3 | Mathlib.RingTheory.HopkinsLevitzki | 3 ≠ 0 | null | false |
_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) | null | 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,... | null | false |
AlgebraicGeometry.Scheme.BirationalOver.partialIso_isOver | Mathlib.AlgebraicGeometry.Birational.Birational | ∀ {S X Y : AlgebraicGeometry.Scheme} (sX : X ⟶ S) (sY : Y ⟶ S) (h : AlgebraicGeometry.Scheme.BirationalOver sX sY),
AlgebraicGeometry.Scheme.PartialIso.IsOver sX sY (AlgebraicGeometry.Scheme.BirationalOver.partialIso sX sY h) | null | true |
Set.infinite_div | Mathlib.Algebra.Group.Pointwise.Set.Finite | ∀ {α : Type u_1} [inst : Group α] {s t : Set α}, (s / t).Infinite ↔ s.Infinite ∧ t.Nonempty ∨ t.Infinite ∧ s.Nonempty | null | true |
instDistribLatticePrimeMultiset | Mathlib.Data.PNat.Factors | DistribLattice PrimeMultiset | null | 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 | null | true |
_private.Mathlib.Analysis.Real.OfDigits.0.Real.ofDigits_SurjOn._proof_1_1 | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ}, 1 < b → ¬b = 0 | null | 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 | null | 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 | null | 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_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} H]
(LF : CategoryTheory.Functor D H) {F : CategoryTheory.Functor C H} {L : CategoryTheory.Functor C D}
(α : L.comp LF ⟶ F) (W : ... | null | 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 | null | 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 | null | false |
Lean.Meta.LazyDiscrTree.findImportMatches | Lean.Meta.LazyDiscrTree | {α : Type} →
IO.Ref (Option (Lean.Meta.LazyDiscrTree α)) →
(Lean.Name → Lean.AsyncConstantInfo → Lean.MetaM (Array (Lean.Meta.LazyDiscrTree.InitEntry α))) →
optParam (List (List Lean.Meta.LazyDiscrTree.Key)) [] →
optParam ℕ 1000 →
optParam (Option (IO.Ref (Option (Array α)))) none →
... | null | true |
_private.Batteries.Data.List.Lemmas.0.List.nodup_findIdxs._proof_1_1 | Batteries.Data.List.Lemmas | ∀ {a b : ℕ}, a < b → ¬a = b | null | false |
Std.Time.Day.instInhabitedOffset | Std.Time.Date.Unit.Day | Inhabited Std.Time.Day.Offset | null | true |
List.splitAt.go._f | Init.Data.List.Basic | {α : Type u} →
List α → (a : List α) → List.below (motive := fun a => ℕ → List α → List α × List α) a → ℕ → List α → List α × List α | null | false |
ULift.instMeasurableSpace | Mathlib.MeasureTheory.MeasurableSpace.Constructions | {α : Type u_1} → [MeasurableSpace α] → MeasurableSpace (ULift.{u_6, u_1} α) | null | 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 | null | 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 →
(LargeE... | null | 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) | `(•) : A 0 → A i → A i` is the value provided in `GradedMonoid.GMul.mul`, composed with
an `Eq.rec` to turn `A (0 + i)` into `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 | null | 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 | null | false |
_private.Mathlib.Analysis.Distribution.Sobolev.0.TemperedDistribution.MemSobolev.lineDerivOp._simp_1_3 | Mathlib.Analysis.Distribution.Sobolev | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | 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 | null | 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) | The set of pair-self-adjoint endomorphisms are a submodule of the type of all endomorphisms. | true |
MaxTropical.mulRightStrictMono | Mathlib.Algebra.Tropical.Basic | ∀ {R : Type u} [inst : Preorder R] [inst_1 : Add R] [AddRightStrictMono R], MulRightStrictMono (MaxTropical R) | null | 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 κ) ... | null | true |
Lake.ToolchainVer.nightly.sizeOf_spec | Lake.Util.Version | ∀ (date : Lake.Date) (rev : optParam (Option ℕ) none),
sizeOf (Lake.ToolchainVer.nightly date rev) = 1 + sizeOf date + sizeOf rev | null | true |
Real.instNormedAddCommGroupAngle._aux_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | Real.Angle | null | 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₂ | null | false |
isConnected_Icc | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {a b : α}, a ≤ b → IsConnected (Set.Icc a b) | null | true |
ValuativeRel.RankLeOneStruct.mk._flat_ctor | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | {R : Type u_1} →
[inst : Semiring R] →
[inst_1 : ValuativeRel R] →
(emb : ValuativeRel.ValueGroupWithZero R →*₀ NNReal) → StrictMono ⇑emb → ValuativeRel.RankLeOneStruct R | null | false |
Aesop.GlobalRuleSet.modifyBaseM | Aesop.RuleSet | {m : Type → Type u_1} →
[Monad m] → (Aesop.BaseRuleSet → m Aesop.BaseRuleSet) → Aesop.GlobalRuleSet → m Aesop.GlobalRuleSet | null | 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.orthogonalProjectionOnto x = (K.projectionOnto Kᗮ ⋯) x | **Alias** of `Submodule.orthogonalProjectionOnto_apply_eq_projectionOnto`. | 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} | `log` is operator monotone. | true |
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.initFn._@.Mathlib.Tactic.GCongr.Core.703138361._hygCtx._hyg.2 | Mathlib.Tactic.GCongr.Core | IO Unit | Attribute marking "generalized congruence" (`gcongr`) lemmas. Such lemmas must have a
conclusion of a form such as `f x₁ y z₁ ∼ f x₂ y z₂`; that is, a relation between the application of
a function to two argument lists, in which the "varying argument" pairs (here `x₁`/`x₂` and
`z₁`/`z₂`) are all free variables. These... | false |
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) | null | true |
toWeakSpaceCLM_bijective | Mathlib.Topology.Algebra.Module.Spaces.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) | null | true |
UnivLE.succ | Mathlib.Basic.UnivLE | ∀ [UnivLE.{u, v}], UnivLE.{u, v + 1} | This is redundant as an instance given the below. | 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 : CategoryT... | null | true |
LibraryNote.«reducible_non-instances» | Mathlib.Algebra.HierarchyDesign | Batteries.Util.LibraryNote | Some definitions that define objects of a class cannot be instances, because they have an
explicit argument that does not occur in the conclusion. An example is `Preorder.lift` that has a
function `f : α → β` as an explicit argument to lift a preorder on `β` to a preorder on `α`.
If these definitions are used to defin... | 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 | null | true |
ImportGraph.Shake.instOrdDeclDeclNeedsKind | ImportGraph.Shake.DeclNeeds | Ord ImportGraph.Shake.DeclDeclNeedsKind | null | 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 | null | true |
Lean.Meta.typeFormerTypeLevelQuick._unsafe_rec | Lean.Meta.InferType | Lean.Expr → Option Lean.Level | null | false |
AddSubsemigroup.instIsAddFGSubtypeMemMap | Mathlib.GroupTheory.Finiteness | ∀ {M : Type u_1} {M' : Type u_2} [inst : Add M] [inst_1 : Add M'] {P : AddSubsemigroup M} (f : M →ₙ+ M') [IsAddFG ↥P],
IsAddFG ↥(AddSubsemigroup.map f P) | null | true |
CategoryTheory.Discrete.hom_eq | Mathlib.CategoryTheory.Discrete.Basic | ∀ {α : Type u₁} {X Y : CategoryTheory.Discrete α} {f g : X ⟶ Y}, f = g | null | true |
String.utf8EncodeChar_eq_utf8EncodeCharFast | Init.Data.String.Decode | String.utf8EncodeChar = String.utf8EncodeCharFast | null | 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 | null | false |
Relation.ReflGen.recOn | Mathlib.Logic.Relation | ∀ {α : Type 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 | null | false |
String.skipPrefix?_slice_eq_some_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat : String.Slice} {s : String} {pos : s.Pos}, s.skipPrefix? pat = some pos ↔ ∃ t, pos.Splits pat.copy t | null | true |
Mathlib.Tactic.Ring.Common.Cache.nat | Mathlib.Tactic.Ring.Common | Mathlib.Tactic.Ring.Common.Cache Mathlib.Tactic.Ring.Common.sℕ | A precomputed `Cache` for `ℕ`. | true |
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 ⋯ | null | 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.L... | null | true |
Lean.Meta.ExtractLetsConfig.lift._default | Init.MetaTypes | Bool | null | 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 | null | 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 ℕ | null | 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ᵐᵒᵖ | The multiplicative opposite of an orthonormal basis `b`, i.e., `b i ↦ op (b i)`. | 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 | null | false |
AddMonoidAlgebra.instBialgebra | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | (R : Type u_1) →
(A : Type u_3) →
(M : Type u_8) →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [Bialgebra R A] → [inst_3 : AddMonoid M] → Bialgebra R (AddMonoidAlgebra A M) | null | 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₁) Categ... | null | true |
Measurable.setOf | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} [inst : MeasurableSpace α] {p : α → Prop}, Measurable p → MeasurableSet {a | p a} | **Alias** of the reverse direction of `measurableSet_setOfPred`. | true |
Lean.Lsp.instFromJsonTextDocumentPositionParams.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.TextDocumentPositionParams | null | 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' | The *Jacobi sum* of two multiplicative characters on a finite commutative ring. | 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) | null | false |
Path.Homotopy.reflTransSymmAux._proof_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | (1 + 1).AtLeastTwo | null | 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 | null | false |
ValuationSubring.instFieldSubtypeMemTop._proof_16 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (a : ℚ≥0) (a_1 : ↥⊤), a • ↑a_1 ∈ ⊤ | null | false |
Lean.Elab.Term.ToDepElimPattern.Context.explicitPatternVars | Lean.Elab.Match | Lean.Elab.Term.ToDepElimPattern.Context → Array Lean.FVarId | Pattern variables that were explicitly provided by the user.
Recall that implicit parameters and `_` are elaborated as metavariables, and then converted into pattern variables
by the `normalize` procedure.
| true |
Metric.hausdorffEDist | Mathlib.Topology.MetricSpace.HausdorffDistance | {α : Type u_2} → [PseudoEMetricSpace α] → Set α → Set α → ENNReal | The Hausdorff edistance between two sets is the smallest `r` such that each set
is contained in the `r`-neighborhood of the other one | true |
CategoryTheory.Limits.equalizer.ι_of_eq | Mathlib.CategoryTheory.Limits.Shapes.Equalizers | ∀ {C : Type u} {X Y : C} [inst : CategoryTheory.Category.{v, u} C] {f g : X ⟶ Y}
[inst_1 : CategoryTheory.Limits.HasEqualizer f g],
f = g → CategoryTheory.IsIso (CategoryTheory.Limits.equalizer.ι f g) | The equalizer of `(f, g)`, where `f = g`, is an isomorphism. | true |
_private.Mathlib.Topology.NoetherianSpace.0.TopologicalSpace.noetherianSpace_iff_isCompact._proof_1_2 | Mathlib.Topology.NoetherianSpace | 3 ≠ 0 | null | false |
Mathlib.Tactic.Ring.Common.RingCompute.noConfusionType | Mathlib.Tactic.Ring.Common | Sort u →
{u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
Mathlib.Tactic.Ring.Common.RingCompute BaseType sα →
{u' : Lean.Level} →
{α' : Q(Type u')} →
{BaseType' : Q(«$α'») → Type} →
... | null | false |
_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 | null | 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.fli... | null | true |
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 α | Consider an extended distance on a topological space, for which the neighborhoods can be
expressed in terms of the distance. Then we define the emetric space structure associated to this
distance, with a topology defeq to the initial one. | 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.A... | null | false |
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) | null | false |
Std.Time.Weekday.instDecidableLeOrdinal | Std.Time.Date.Unit.Weekday | {x y : Std.Time.Weekday.Ordinal} → Decidable (x ≤ y) | null | 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₂ : ... | null | 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)... | null | 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 | null | false |
Lean.Meta.Sym.State.share._default | Lean.Meta.Sym.SymM | Lean.Meta.Sym.AlphaShareCommon.State | null | 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 | If two values compare equal, then they are boolean equal. | 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.... | null | 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 | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.