name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
add_mem_closedBall_add_iff | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedAddCommGroup E] {a b : E} {r : ℝ} {c : E},
a + c ∈ Metric.closedBall (b + c) r ↔ a ∈ Metric.closedBall b r | null | true |
circleAverage_log_norm_sub_const_eq_posLog | Mathlib.Analysis.SpecialFunctions.Integrals.PosLog | ∀ {a : ℂ}, Real.circleAverage (fun x => Real.log ‖x - a‖) 0 1 = ‖a‖.posLog | The `circleAverage (log ‖· - a‖) 0 1` equals `log⁺ ‖a‖`.
| true |
Finset.val_covBy_val._simp_1 | Mathlib.Data.Finset.Grade | ∀ {α : Type u_1} {s t : Finset α}, (s.val ⋖ t.val) = (s ⋖ t) | null | false |
_private.Mathlib.Dynamics.Ergodic.MeasurePreserving.0.MeasureTheory.MeasurePreserving.iterate.match_1_1 | Mathlib.Dynamics.Ergodic.MeasurePreserving | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
Matrix.UnitaryGroup.transpose_inv_eq_map_star | Mathlib.LinearAlgebra.UnitaryGroup | ∀ {n : Type u} [inst : DecidableEq n] [inst_1 : Fintype n] {α : Type v} [inst_2 : CommRing α] [inst_3 : StarRing α]
(U : ↥(Matrix.unitaryGroup n α)), (Matrix.UnitaryGroup.transpose U)⁻¹ = Matrix.UnitaryGroup.map_star U | null | true |
SSet.Truncated.Edge.CompStruct.rec | Mathlib.AlgebraicTopology.SimplicialSet.CompStructTruncated | {X : SSet.Truncated 2} →
{x₀ x₁ x₂ : X.obj (Opposite.op { obj := { len := 0 }, property := SSet.Truncated.Edge._proof_1 })} →
{e₀₁ : SSet.Truncated.Edge x₀ x₁} →
{e₁₂ : SSet.Truncated.Edge x₁ x₂} →
{e₀₂ : SSet.Truncated.Edge x₀ x₂} →
{motive : e₀₁.CompStruct e₁₂ e₀₂ → Sort u_1} →
... | null | false |
Aesop.DisplayRuleName.casesOn | Aesop.Rule.Name | {motive : Aesop.DisplayRuleName → Sort u} →
(t : Aesop.DisplayRuleName) →
((n : Aesop.RuleName) → motive (Aesop.DisplayRuleName.ruleName n)) →
motive Aesop.DisplayRuleName.normSimp → motive Aesop.DisplayRuleName.normUnfold → motive t | null | false |
IsSelfAdjoint.star_eq | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Star R] {x : R}, IsSelfAdjoint x → star x = x | null | true |
AlgebraicGeometry.sigmaOpenCover | Mathlib.AlgebraicGeometry.Limits | {σ : Type v} → (g : σ → AlgebraicGeometry.Scheme) → [inst : Small.{u, v} σ] → (∐ g).OpenCover | The cover of `∐ X` by the `Xᵢ`. | true |
Int32.xor_eq_zero_iff._simp_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int32}, (a ^^^ b = 0) = (a = b) | null | false |
Lean.Server.LoadedILean.moduleUri | Lean.Server.References | Lean.Server.LoadedILean → Lean.Lsp.DocumentUri | URI of the module of this ILean. | true |
Stream'.inits_eq | Mathlib.Data.Stream.Init | ∀ {α : Type u} (s : Stream' α), s.inits = Stream'.cons [s.head] (Stream'.map (List.cons s.head) s.tail.inits) | null | true |
CategoryTheory.HasRightDual.noConfusion | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | {P : Sort u} →
{C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{X : C} →
{t : CategoryTheory.HasRightDual X} →
{C' : Type u₁} →
{inst' : CategoryTheory.Category.{v₁, u₁} C'} →
{inst'_1 : ... | null | false |
Polynomial.expand_mul | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (f : Polynomial R),
(Polynomial.expand R (p * q)) f = (Polynomial.expand R p) ((Polynomial.expand R q) f) | null | true |
AsBoolRing | Mathlib.Algebra.Ring.BooleanRing | Type u_4 → Type u_4 | Type synonym to view a Boolean ring as a Boolean algebra. | true |
lpSubmodule._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ (𝕜 : Type u_3) {α : Type u_1} (E : α → Type u_2) (p : ENNReal) [inst : (i : α) → NormedAddCommGroup (E i)]
[inst_1 : NormedRing 𝕜] [inst_2 : (i : α) → Module 𝕜 (E i)] [∀ (i : α), IsBoundedSMul 𝕜 (E i)] (c : 𝕜),
∀ f ∈ (lp E p).carrier, c • f ∈ (lp E p).carrier | null | false |
Nat.instAssociativeHAnd | Init.Data.Nat.Bitwise.Lemmas | Std.Associative fun x1 x2 => x1 &&& x2 | null | true |
_private.Std.Tactic.BVDecide.LRAT.Internal.Rup.0.Std.Tactic.BVDecide.LRAT.Internal.State.propagateHints.match_1 | Std.Tactic.BVDecide.LRAT.Internal.Rup | (motive : Option ℕ → Sort u_1) → (unit : Option ℕ) → ((u : ℕ) → motive (some u)) → (Unit → motive none) → motive unit | null | false |
MeasureTheory.lpMeasSubgroupToLpTrim_neg | Mathlib.MeasureTheory.Function.ConditionalExpectation.AEMeasurable | ∀ {α : Type u_1} {F : Type u_2} {p : ENNReal} [inst : NormedAddCommGroup F] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} (hm : m ≤ m0) (f : ↥(MeasureTheory.lpMeasSubgroup F m p μ)),
MeasureTheory.lpMeasSubgroupToLpTrim F p μ hm (-f) = -MeasureTheory.lpMeasSubgroupToLpTrim F p μ hm f | null | true |
_private.Lean.Environment.0.Lean.RealizationContext.casesOn | Lean.Environment | {motive : Lean.RealizationContext✝ → Sort u} →
(t : Lean.RealizationContext✝) →
((env : NonScalar) →
(opts : Lean.Options) →
(realizeMapRef : IO.Ref (Lean.NameMap NonScalar)) →
motive { env := env, opts := opts, realizeMapRef := realizeMapRef }) →
motive t | null | false |
Ordinal.mul_div_le | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a b : Ordinal.{u_4}), b * (a / b) ≤ a | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.elabParserName.match_1 | Lean.Elab.Syntax | (motive : Option Lean.Parser.ParserResolution → Sort u_1) →
(__do_lift : Option Lean.Parser.ParserResolution) →
((n : Lean.Parser.ParserResolution) → motive (some n)) → (Unit → motive none) → motive __do_lift | null | false |
Lean.ResolveName.resolveGlobalName | Lean.ResolveName | Lean.Environment → Lean.Options → Lean.Name → List Lean.OpenDecl → Lean.Name → List (Lean.Name × List String) | Primitive global name resolution procedure. It does not trigger actions associated with reserved names.
Recall that Lean has reserved names. For example, a definition `foo` has a reserved name `foo.def` for theorem
containing stating that `foo` is equal to its definition. The action associated with `foo.def`
automatica... | true |
_private.Lean.Meta.IndPredBelow.0.Lean.Meta.IndPredBelow.isIH.match_1 | Lean.Meta.IndPredBelow | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((f : Lean.FVarId) → motive (Lean.Expr.fvar f)) → ((x : Lean.Expr) → motive x) → motive x | null | false |
_private.Init.Prelude.0.Lean.Macro.State.mk.noConfusion | Init.Prelude | {P : Sort u} →
{macroScope : Lean.MacroScope} →
{traceMsgs : List (Lean.Name × String)} →
{expandedMacroDecls : List Lean.Name} →
{macroScope' : Lean.MacroScope} →
{traceMsgs' : List (Lean.Name × String)} →
{expandedMacroDecls' : List Lean.Name} →
{ macroScope := ... | null | false |
NonUnitalRingHom.op_apply_apply | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_2} {S : Type u_3} [inst : NonUnitalNonAssocSemiring R] [inst_1 : NonUnitalNonAssocSemiring S]
(f : R →ₙ+* S) (a : Rᵐᵒᵖ), (NonUnitalRingHom.op f) a = (↑(AddMonoidHom.mulOp f.toAddMonoidHom)).toFun a | null | true |
Commute.function_commute_mul_right | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Semigroup G] {a b : G}, Commute a b → Function.Commute (fun x => x * a) fun x => x * b | null | true |
_private.Mathlib.Algebra.GroupWithZero.Associated.0.Associates.mk_isRelPrime_iff._simp_1_2 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {p : Associates M → Prop},
(∀ (a : Associates M), p a) = ∀ (a : M), p (Associates.mk a) | null | false |
Turing.ToPartrec.Cont._sizeOf_inst | Mathlib.Computability.TuringMachine.Config | SizeOf Turing.ToPartrec.Cont | null | false |
NNRat.den_one | Mathlib.Data.NNRat.Defs | NNRat.den 1 = 1 | null | true |
List.getElem?_append_right._f | Init.Data.List.Lemmas | ∀ {α : Type u_1} (x : List α)
(f :
List.below (motive := fun x => ∀ (x_1 : List α) (x_2 : ℕ), x.length ≤ x_2 → (x ++ x_1)[x_2]? = x_1[x_2 - x.length]?)
x)
(x_1 : List α) (x_2 : ℕ), x.length ≤ x_2 → (x ++ x_1)[x_2]? = x_1[x_2 - x.length]? | null | false |
Std.DHashMap.Raw.Const.get!_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {γ : Type w} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [inst_3 : LawfulHashable α] [inst_4 : Inhabited γ] {f : α → β → Option γ} {k : α} (h : m.WF),
Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.filterMap f m) k =
((Std.DHashMap.Ra... | null | true |
_private.Mathlib.Data.List.PeriodicityLemma.0.List.HasPeriod.drop_of_hasPeriod_add._proof_1_11 | Mathlib.Data.List.PeriodicityLemma | ∀ {α : Type u_1} {q : ℕ} {w : List α} (i : ℕ), 3 * q + i + 1 ≤ w.length → 3 * q + i < w.length | null | false |
Submodule.restrictScalars_mono | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] {s t : Submodule R M},
s ≤ t → Submodule.restrictScalars S s ≤ Submodule.restrictScalars S t | null | true |
Std.TreeSet.Raw.WF.merge | Std.Data.TreeSet.Raw.WF | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet.Raw α cmp}, t₁.WF → (t₁.merge t₂).WF | null | true |
LatticeCon.ker._proof_2 | Mathlib.Order.Lattice.Congruence | ∀ {F : Type u_3} {α : Type u_1} {β : Type u_2} [inst : Lattice α] [inst_1 : Lattice β] [inst_2 : FunLike F α β]
[LatticeHomClass F α β] (f : F) {w x y z : α},
(Setoid.ker ⇑f) w x → (Setoid.ker ⇑f) y z → (Setoid.ker ⇑f) (w ⊓ y) (x ⊓ z) | null | false |
ContRepresentation.coind₁Res_apply | Mathlib.RepresentationTheory.Continuous.Basic | ∀ {R : Type u_1} {V : Type u_3} [inst : Ring R] [inst_1 : AddCommGroup V] [inst_2 : TopologicalSpace V]
[inst_3 : IsTopologicalAddGroup V] [inst_4 : Module R V] {G : Type u_7} {H : Type u_8} [inst_5 : Group G]
[inst_6 : TopologicalSpace G] [inst_7 : TopologicalSpace R] [inst_8 : ContinuousSMul R V] [inst_9 : Group ... | null | true |
Field.insepDegree | Mathlib.FieldTheory.SeparableClosure | (F : Type u) → (E : Type v) → [inst : Field F] → [inst_1 : Field E] → [Algebra F E] → Cardinal.{v} | The (infinite) inseparable degree for a general field extension `E / F` is defined
to be the degree of `E / separableClosure F E`. | true |
Int.emod_add_cancel_left | Init.Data.Int.DivMod.Lemmas | ∀ {m n k i : ℤ}, (i + m) % n = (i + k) % n ↔ m % n = k % n | null | true |
Std.DTreeMap.Internal.Impl.Ordered | Std.Data.DTreeMap.Internal.Ordered | {α : Type u} → {β : α → Type v} → [Ord α] → Std.DTreeMap.Internal.Impl α β → Prop | Implementation detail of the tree map | true |
Matrix.Exists._f | Mathlib.Data.Matrix.Reflection | {α : Type u_1} →
(x : ℕ) →
Nat.below (motive := fun x => (x_1 : ℕ) → (Matrix (Fin x) (Fin x_1) α → Prop) → Prop) x →
(x_1 : ℕ) → (Matrix (Fin x) (Fin x_1) α → Prop) → Prop | null | false |
Subgroup.le_closure_toSubmonoid | Mathlib.Algebra.Group.Subgroup.Lattice | ∀ {G : Type u_1} [inst : Group G] (S : Set G), Submonoid.closure S ≤ (Subgroup.closure S).toSubmonoid | null | true |
_private.Mathlib.Algebra.Star.Module.0.IsIdempotentElem.star_iff._simp_1_1 | Mathlib.Algebra.Star.Module | ∀ {R : Type u} {inst : Mul R} [self : StarMul R] (r s : R), star s * star r = star (r * s) | null | false |
Finite.recOn | Mathlib.Basic.Finite.Defs | ∀ {α : Sort u_3} {motive : Finite α → Prop} (t : Finite α), (∀ {n : ℕ} (a : α ≃ Fin n), motive ⋯) → motive t | null | false |
Lean.Elab.ConfigEval.EvalExpr.evalOptionExpr | Lean.Elab.ConfigEval.Instances | {α : Type} → (Lean.Expr → Lean.MetaM α) → Lean.Expr → Lean.MetaM (Option α) | null | true |
List.filter_filterMap | Init.Data.List.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {f : α → Option β} {p : β → Bool} {l : List α},
List.filter p (List.filterMap f l) = List.filterMap (fun x => Option.filter p (f x)) l | null | true |
Std.HashMap.getElem?_alter | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α]
{k k' : α} {f : Option β → Option β}, (m.alter k f)[k']? = if (k == k') = true then f m[k]? else m[k']? | null | true |
Module.Basis.reindexFinsetRange_self | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_7} {R : Type u_8} {M : Type u_9} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(b : Module.Basis ι R M) [inst_3 : Fintype ι] [inst_4 : DecidableEq M] (i : ι)
(h : optParam (b i ∈ Finset.image (⇑b) Finset.univ) ⋯), b.reindexFinsetRange ⟨b i, h⟩ = b i | null | true |
_private.Batteries.Data.AssocList.Lemmas.0.List.filter.match_1.splitter | Batteries.Data.AssocList.Lemmas | (motive : Bool → Sort u_1) → (x : Bool) → (Unit → motive true) → (Unit → motive false) → motive x | null | true |
Lean.Lsp.TextDocumentRegistrationOptions.mk.injEq | Lean.Data.Lsp.Basic | ∀ (documentSelector? documentSelector?_1 : Option Lean.Lsp.DocumentSelector),
({ documentSelector? := documentSelector? } = { documentSelector? := documentSelector?_1 }) =
(documentSelector? = documentSelector?_1) | null | true |
Lean.Elab.PartialTermInfo.mk | Lean.Elab.InfoTree.Types | Lean.Elab.ElabInfo → Lean.LocalContext → Option Lean.Expr → Lean.Elab.PartialTermInfo | null | true |
Aesop.Script.DynStructureM.Context.noConfusion | Aesop.Script.StructureDynamic | {P : Sort u} →
{t t' : Aesop.Script.DynStructureM.Context} → t = t' → Aesop.Script.DynStructureM.Context.noConfusionType P t t' | null | false |
MeasureTheory.Measure.count.isFiniteMeasure | Mathlib.MeasureTheory.Measure.Count | ∀ {α : Type u_1} [inst : MeasurableSpace α] [Finite α], MeasureTheory.IsFiniteMeasure MeasureTheory.Measure.count | null | true |
Polynomial.map_prod | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} {S : Type v} [inst : CommSemiring R] [inst_1 : CommSemiring S] (f : R →+* S) {ι : Type u_1}
(g : ι → Polynomial R) (s : Finset ι), Polynomial.map f (∏ i ∈ s, g i) = ∏ i ∈ s, Polynomial.map f (g i) | null | true |
IsLocalRing.specializes_closedPoint | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : IsLocalRing R] (x : PrimeSpectrum R), x ⤳ IsLocalRing.closedPoint R | null | true |
Encodable.encodeSum | Mathlib.Logic.Encodable.Basic | {α : Type u_1} → {β : Type u_2} → [Encodable α] → [Encodable β] → α ⊕ β → ℕ | Explicit encoding function for the sum of two encodable types. | true |
_private.Batteries.Data.Vector.Lemmas.0.Vector.scanlM.loop_toArray | Batteries.Data.Vector.Lemmas | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} {n : ℕ} [inst : Monad m] [LawfulMonad m] (f : β → α → m β)
(as : Vector α n) (h_stop : n ≤ as.toArray.size) (i : ℕ) (hi : i ≤ n) (cur : β) (acc_v : Vector β i)
(acc_a : Array β),
acc_v.toArray = acc_a →
Vector.toArray <$> Vector.scanlM.loop f as cur i ... | null | true |
_private.Mathlib.NumberTheory.LSeries.AbstractFuncEq.0.WeakFEPair.Λ_residue_zero._proof_1_2 | Mathlib.NumberTheory.LSeries.AbstractFuncEq | ∀ (s : ℂ), s ≠ 0 → 1 = s * (1 / s) | null | false |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.processReadBodyState.match_4 | Std.Http.Protocol.H1 | (motive : Std.Http.Protocol.H1.Reader.BodyState → Sort u_1) →
(bodyState : Std.Http.Protocol.H1.Reader.BodyState) →
(Unit → motive (Std.Http.Protocol.H1.Reader.BodyState.fixed 0)) →
((x : Std.Http.Protocol.H1.Reader.BodyState) → motive x) → motive bodyState | null | false |
conjneg_neg'._simp_1 | Mathlib.Algebra.Order.Star.Conjneg | ∀ {G : Type u_1} {R : Type u_2} [inst : AddGroup G] [inst_1 : CommRing R] [inst_2 : PartialOrder R]
[inst_3 : StarRing R] [StarOrderedRing R] {f : G → R}, (conjneg f < 0) = (f < 0) | null | false |
instLocallyFiniteOrderBotSubtypeLtOfDecidableLTOfLocallyFiniteOrder._proof_2 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} [inst : Preorder α] {y : α} [inst_1 : DecidableLT α] [inst_2 : LocallyFiniteOrder α]
(a b : { x // y < x }), b ∈ Finset.subtype (fun x => y < x) (Finset.Ioo y ↑a) ↔ b < a | null | false |
unitOfInvertible | Mathlib.Algebra.Group.Invertible.Basic | {α : Type u} → [inst : Monoid α] → (a : α) → [Invertible a] → αˣ | An `Invertible` element is a unit. | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Monadic.Append.0.Std.IterM.toArray_eq_match_step.match_1.eq_3 | Init.Data.Iterators.Lemmas.Combinators.Monadic.Append | ∀ {α β : Type u_1} {m : Type u_1 → Type u_2} (motive : Std.IterStep (Std.IterM m β) β → Sort u_3)
(h_1 : (it' : Std.IterM m β) → (out : β) → motive (Std.IterStep.yield it' out))
(h_2 : (it' : Std.IterM m β) → motive (Std.IterStep.skip it')) (h_3 : Unit → motive Std.IterStep.done),
(match Std.IterStep.done with
... | null | true |
_private.Mathlib.Control.Fix.0.Part.Fix.approx.match_1.splitter | Mathlib.Control.Fix | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((i : ℕ) → motive i.succ) → motive x | null | true |
_private.Lean.Elab.MacroArgUtil.0.Lean.Elab.Command.expandMacroArg.match_1 | Lean.Elab.MacroArgUtil | (motive : Option Lean.Ident → Sort u_1) →
(id? : Option Lean.Ident) → ((id : Lean.Ident) → motive (some id)) → (Unit → motive none) → motive id? | null | false |
Topology.IsOpenEmbedding.isGeneratedBy | Mathlib.Topology.Convenient.OpenClosed | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {Y : Type u_3}
[inst_1 : TopologicalSpace Y] [∀ (i : ι) (U : TopologicalSpace.Opens (X i)), Topology.IsGeneratedBy X ↥U]
[Topology.IsGeneratedBy X Y] {F : Type u_4} [inst_4 : TopologicalSpace F] {f : F → Y},
Topology.IsOpenEmbedding f →... | null | true |
Batteries.Tactic.TransRelation.implies.sizeOf_spec | Batteries.Tactic.Trans | ∀ (name : Lean.Name) (bi : Lean.BinderInfo),
sizeOf (Batteries.Tactic.TransRelation.implies name bi) = 1 + sizeOf name + sizeOf bi | null | true |
_private.Mathlib.Topology.Order.Basic.0.LeftOrdContinuous.continuousWithinAt_Iic.match_1_3 | Mathlib.Topology.Order.Basic | ∀ {X : Type u_2} {Y : Type u_1} [inst : ConditionallyCompleteLinearOrder Y] {f : X → Y} (z x : Y)
(motive : x ∈ f '' f ⁻¹' Set.Iic z → Prop) (x_1 : x ∈ f '' f ⁻¹' Set.Iic z),
(∀ (b : X) (hb : b ∈ f ⁻¹' Set.Iic z) (heq : f b = x), motive ⋯) → motive x_1 | null | false |
_private.Mathlib.Order.Defs.PartialOrder.0.lt_iff_le_iff_gt_iff_ge._proof_1_1 | Mathlib.Order.Defs.PartialOrder | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (a < b ↔ a ≤ b) ↔ (b < a ↔ b ≤ a) | null | false |
AbstractMeasure.contractFstCLM | Mathlib.NumberTheory.Padics.Measure.Basic | {X : Type u_1} →
{Y : Type u_2} →
{R : Type u_3} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
[inst_2 : CommRing R] →
[inst_3 : TopologicalSpace R] →
[inst_4 : IsTopologicalRing R] →
[LocallyCompactSpace X] →
[i... | `AbstractMeasure.contractFst` bundled with continuity in the function argument. | true |
_private.Mathlib.Tactic.Translate.Reorder.0.Mathlib.Tactic.Translate.elabReorder.match_7 | Mathlib.Tactic.Translate.Reorder | (motive : Std.HashSet ℕ → Sort u_1) → (x : Std.HashSet ℕ) → ((x : Std.HashSet ℕ) → motive x) → motive x | null | false |
ContinuousCohomology.cocycles₀Iso | Mathlib.RepresentationTheory.Homological.ContCohomology.LowDegree | {k : Type u_1} →
{G : Type u_2} →
[inst : Ring k] →
[inst_1 : Group G] →
[inst_2 : TopologicalSpace k] →
[inst_3 : TopologicalSpace G] →
[inst_4 : IsTopologicalGroup G] →
(X : TopRep k G) →
ContinuousCohomology.cocycles X 0 ≅ ↧↥(↑(TopModuleCat.Hom.... | The isomorphism between the zeroth cocycles and the kernel of the zeroth differential. | true |
_private.Std.Sat.CNF.Unit.0.Std.Sat.CNF.entails_clause_unit_iff_unsat_add_neg._simp_1_2 | Std.Sat.CNF.Unit | ∀ {a b : Prop}, (¬(a ∧ b)) = (a → ¬b) | null | false |
NonUnitalNonAssocRing.toHasDistribNeg._proof_4 | Mathlib.Algebra.Ring.Defs | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (a b : α), -a * b = -(a * b) | null | false |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.ImportState.minImports._default | Mathlib.Tactic.Linter.MinImports | Lean.NameSet | null | false |
SimpleGraph.CompleteEquipartiteSubgraph.card_verts | Mathlib.Combinatorics.SimpleGraph.CompleteMultipartite | ∀ {V : Type u_1} {G : SimpleGraph V} {r t : ℕ} (K : G.CompleteEquipartiteSubgraph r t), K.verts.card = r * t | There are `r * t` vertices in a complete equipartite subgraph with `r` parts of size `t`. | true |
CategoryTheory.Functor.commShiftOp_iso_eq | Mathlib.CategoryTheory.Shift.Opposite | ∀ {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] (A : Type u_3) [inst_2 : AddMonoid A]
[inst_3 : CategoryTheory.HasShift C A] [inst_4 : CategoryTheory.HasShift D A] (F : CategoryTheory.Functor C D)
[inst_5 : F.CommShift A] (a : A),
Cat... | null | true |
LinearOrder.liftWithOrd._proof_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_1} [inst : LinearOrder β] [inst_1 : Ord α] (f : α → β),
(∀ (a b : α), compare a b = compare (f a) (f b)) → ∀ (x x_1 : α), compare (f x) (f x_1) = compare x x_1 | null | false |
Part.inv_mem_inv | Mathlib.Data.Part | ∀ {α : Type u_1} [inst : Inv α] (a : Part α), ∀ ma ∈ a, ma⁻¹ ∈ a⁻¹ | null | true |
Std.Time.Timestamp.subWeeks | Std.Time.DateTime.Timestamp | Std.Time.Timestamp → Std.Time.Week.Offset → Std.Time.Timestamp | Subtracts a `Week.Offset` from the given `Timestamp`.
| true |
Module.fgSystem.equiv_comp_of | Mathlib.Algebra.Colimit.Finiteness | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : DecidableEq (Submodule R M)] (N : { N // N.FG }),
↑(Module.fgSystem.equiv R M) ∘ₗ Module.DirectLimit.of R { N // N.FG } (fun i => ↥↑i) (Module.fgSystem R M) N =
(↑N).subtype | null | true |
Std.IterM.drain_eq_map_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [Std.Iterators.Finite α m] [inst_2 : Monad m]
[LawfulMonad m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β},
it.drain = (fun x => PUnit.unit) <$> it.toList | null | true |
groupHomology.instPreservesZeroMorphismsRepChainComplexModuleCatNatChainsFunctor | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ (k G : Type u) [inst : CommRing k] [inst_1 : Group G], (groupHomology.chainsFunctor k G).PreservesZeroMorphisms | null | true |
GenContFract.IntFractPair.mapFr.eq_1 | Mathlib.Algebra.ContinuedFractions.Computation.TerminatesIffRat | ∀ {K : Type u_1} {β : Type u_2} (f : K → β) (gp : GenContFract.IntFractPair K),
GenContFract.IntFractPair.mapFr f gp = { b := gp.b, fr := f gp.fr } | null | true |
String.Slice.all_slice_iff | Init.Data.String.Lemmas.Pattern.TakeDrop.String | ∀ {pat s : String.Slice}, s.all pat = true ↔ ∃ n, s.copy = String.join (List.replicate n pat.copy) | null | true |
MeasureTheory.Measure.InnerRegularWRT.eq_of_innerRegularWRT_of_forall_eq | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {p q : Set α → Prop}
{ν : MeasureTheory.Measure α},
μ.InnerRegularWRT p q → ν.InnerRegularWRT p q → (∀ (U : Set α), p U → μ U = ν U) → ∀ {U : Set α}, q U → μ U = ν U | null | true |
Module.Relations.Solution.congr_var | Mathlib.Algebra.Module.Presentation.Basic | ∀ {A : Type u} [inst : Ring A] {relations : Module.Relations A} {M : Type v} [inst_1 : AddCommGroup M]
[inst_2 : Module A M] {solution solution' : relations.Solution M},
solution = solution' → ∀ (g : relations.G), solution.var g = solution'.var g | null | true |
PartialHomeomorph.noConfusionType | Mathlib.Topology.PartialHomeomorph.Defs | Sort u →
{X : Type u_5} →
{Y : Type u_6} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
PartialHomeomorph X Y →
{X' : Type u_5} →
{Y' : Type u_6} →
[inst' : TopologicalSpace X'] → [inst'_1 : TopologicalSpace Y'] → PartialHomeomorph... | null | false |
BoxIntegral.Box.mem_mk._simp_1 | Mathlib.Analysis.BoxIntegral.Box.Basic | ∀ {ι : Type u_1} {l u x : ι → ℝ} {H : ∀ (i : ι), l i < u i},
(x ∈ { lower := l, upper := u, lower_lt_upper := H }) = ∀ (i : ι), x i ∈ Set.Ioc (l i) (u i) | null | false |
IO.FS.SystemTime.noConfusion | Init.System.IO | {P : Sort u} → {t t' : IO.FS.SystemTime} → t = t' → IO.FS.SystemTime.noConfusionType P t t' | null | false |
OpenPartialHomeomorph.mdifferentiableOn_extend | Mathlib.Geometry.Manifold.MFDeriv.Atlas | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {e : OpenPartialHomeomorph M H},
e ∈ ... | null | true |
CochainComplex.HomComplex.CohomologyClass.mk_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ), CochainComplex.HomComplex.CohomologyClass.mk 0 = 0 | null | true |
Finsupp.prod_finset_sum_index | Mathlib.Algebra.BigOperators.Finsupp.Basic | ∀ {α : Type u_1} {ι : Type u_2} {M : Type u_8} {N : Type u_10} [inst : AddCommMonoid M] [inst_1 : CommMonoid N]
{s : Finset ι} {g : ι → α →₀ M} {h : α → M → N},
(∀ (a : α), h a 0 = 1) →
(∀ (a : α) (b₁ b₂ : M), h a (b₁ + b₂) = h a b₁ * h a b₂) → ∏ i ∈ s, (g i).prod h = (∑ i ∈ s, g i).prod h | **Alias** of `Finsupp.prod_finsetSum_index`. | true |
CategoryTheory.Limits.WalkingParallelFamily.Hom.line.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} →
{P : Sort u} →
{a a' : J} →
CategoryTheory.Limits.WalkingParallelFamily.Hom.line a = CategoryTheory.Limits.WalkingParallelFamily.Hom.line a' →
(a ≍ a' → P) → P | null | false |
Lean.Widget.RpcEncodablePacket._@.Lean.Widget.Types.2243429567._hygCtx._hyg.1 | Lean.Widget.Types | Type | null | false |
InformationTheory.klDiv_eq_integral_klFun | Mathlib.InformationTheory.KullbackLeibler.Basic | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ ν : MeasureTheory.Measure α} [MeasureTheory.IsFiniteMeasure μ]
[MeasureTheory.IsFiniteMeasure ν],
InformationTheory.klDiv μ ν =
if μ.AbsolutelyContinuous ν ∧ MeasureTheory.Integrable (MeasureTheory.llr μ ν) μ then
ENNReal.ofReal (∫ (x : α), InformationTheory.kl... | null | true |
CategoryTheory.Localization.Monoidal.triangle | Mathlib.CategoryTheory.Localization.Monoidal.Basic | ∀ {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}
{W : CategoryTheory.MorphismProperty C} [inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : W.IsMonoidal]
[inst_4 : L.IsLocalization W] {unit : D} {ε : ... | The pointwise triangle identity in the localized monoidal category. | true |
_private.Mathlib.Order.Atoms.0.bot_covBy_iff._simp_1_1 | Mathlib.Order.Atoms | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (⊥ < a) = (a ≠ ⊥) | null | false |
Std.Internal.List.getKey!_map | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [EquivBEq α] [inst_2 : Inhabited α]
{f : (a : α) → β a → γ a} {l : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKey! k (List.map (fun p => ⟨p.fst, f p.fst p.snd⟩) l) = Std.Internal.List.getKey! k l | null | true |
Lean.Lsp.instToJsonRpcReleaseParams.toJson | Lean.Data.Lsp.Extra | Lean.Lsp.RpcReleaseParams → Lean.Json | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.