name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ordinal.isEquivalent.match_3 | Mathlib.SetTheory.Ordinal.Basic | ∀ {x y : WellOrder}
(motive :
(match x with
| { α := α, r := r, wo := wo } =>
match y with
| { α := α_1, r := s, wo := wo } => Nonempty (r ≃r s)) →
Prop)
(x_1 :
match x with
| { α := α, r := r, wo := wo } =>
match y with
| { α := α_1, r := s, wo := wo } => Nonempt... | null | false |
_private.Mathlib.Data.EReal.Operations.0.EReal.mul_pos_iff._simp_1_1 | Mathlib.Data.EReal.Operations | ∀ {a b : Prop}, (a ∧ b) = (b ∧ a) | null | false |
ConvexCone.coe_iInf._simp_1 | Mathlib.Geometry.Convex.Cone.Basic | ∀ {R : Type u_2} {M : Type u_4} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : AddCommMonoid M]
[inst_3 : SMul R M] {ι : Sort u_7} (f : ι → ConvexCone R M), ⋂ i, ↑(f i) = ↑(iInf f) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_rev._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (i : Fin w), ¬w - (w - (↑i + 1) + 1) = ↑i → False | null | false |
PiTensorProduct.mapL_pow | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} {E : ι → Type u_3} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)] (f : (i : ι) → E i →L[𝕜] E i) (n : ℕ),
PiTensorProduct.mapL (f ^ n) = PiTensorProduct.mapL f ^ n | null | true |
CategoryTheory.ShortComplex.RightHomologyMapData.id_φH | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.RightHomologyData),
(CategoryTheory.ShortComplex.RightHomologyMapData.id h).φH = CategoryTheory.CategoryStruct.id h.H | null | true |
Lean.PrettyPrinter.Delaborator.delabApp | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | Default delaborator for applications.
| true |
Aesop.GoalState.provenByNormalization | Aesop.Tree.Data | Aesop.GoalState | null | true |
Std.ExtDTreeMap.Const.insertMany_cons | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{l : List (α × β)} {p : α × β},
Std.ExtDTreeMap.Const.insertMany t (p :: l) = Std.ExtDTreeMap.Const.insertMany (t.insert p.1 p.2) l | null | true |
sq_le_sq₀ | Mathlib.Algebra.Order.GroupWithZero.Basic | ∀ {M₀ : Type u_2} [inst : MonoidWithZero M₀] [inst_1 : LinearOrder M₀] [PosMulStrictMono M₀] {a b : M₀} [MulPosMono M₀],
0 ≤ a → 0 ≤ b → (a ^ 2 ≤ b ^ 2 ↔ a ≤ b) | null | true |
ProbabilityTheory.Kernel.iIndepFun_zero_right | Mathlib.Probability.Independence.Kernel.IndepFun | ∀ {α : Type u_1} {Ω : Type u_2} {ι : Type u_3} {_mα : MeasurableSpace α} {_mΩ : MeasurableSpace Ω}
{κ : ProbabilityTheory.Kernel α Ω} {β : ι → Type u_10} {m : (x : ι) → MeasurableSpace (β x)} {f : (x : ι) → Ω → β x},
ProbabilityTheory.Kernel.iIndepFun f κ 0 | null | true |
Turing.TM0to1.trCfg | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
[inst : Inhabited Γ] →
{Λ : Type u_2} →
[inst_1 : Inhabited Λ] →
Turing.TM0.Machine Γ Λ → Turing.TM0.Cfg Γ Λ → Turing.TM1.Cfg Γ (Turing.TM0to1.Λ' Γ Λ) Unit | The configuration translation. | true |
Set.piecewise_insert_self | Mathlib.Data.Set.Piecewise | ∀ {α : Type u_1} {δ : α → Sort u_6} (s : Set α) (f g : (i : α) → δ i) {j : α}
[inst : (i : α) → Decidable (i ∈ insert j s)], (insert j s).piecewise f g j = f j | null | true |
FundamentalGroupoidFunctor.piToPiTop_map | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | ∀ {I : Type u} (X : I → TopCat) {X_1 Y : (i : I) → ↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj (X i))}
(p : X_1 ⟶ Y), (FundamentalGroupoidFunctor.piToPiTop X).map p = Path.Homotopic.pi p | null | true |
Lean.Meta.instDecidableEqProjReductionKind._proof_2 | Lean.Meta.Basic | ∀ (x y : Lean.Meta.ProjReductionKind), ¬x.ctorIdx = y.ctorIdx → x = y → False | null | false |
Real.coshOpenPartialHomeomorph._proof_7 | Mathlib.Analysis.SpecialFunctions.Arcosh | IsOpen (Set.Ioi 1) | null | false |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.reflects_cofiltered_limits | Mathlib.CategoryTheory.Limits.Preserves.Filtered | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F : CategoryTheory.Functor C D}
[self : CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize.{w', w, v₁, v₂, u₁, u₂} F] (J : Type w)
[inst_2 : CategoryTheory.Category.{w', w} J] [CategoryTheory... | null | true |
Complex.logDeriv_exp | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | logDeriv Complex.exp = 1 | null | true |
MeasureTheory.AEStronglyMeasurable._auto_1 | Mathlib.MeasureTheory.Function.StronglyMeasurable.AEStronglyMeasurable | Lean.Syntax | null | false |
CategoryTheory.PreOneHypercover.Homotopy.mk | Mathlib.CategoryTheory.Sites.Hypercover.Homotopy | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{S : C} →
{E : CategoryTheory.PreOneHypercover S} →
{F : CategoryTheory.PreOneHypercover S} →
{f g : E.Hom F} →
(H : (i : E.I₀) → F.I₁ (f.s₀ i) (g.s₀ i)) →
(a : (i : E.I₀) → E.X i ⟶ F.Y (H i)) →
... | null | true |
Std.Time.TimeZone.TZif.Header | Std.Time.Zoned.Database.TzIf | Type | Represents the header of a TZif file, containing metadata about the file's structure.
| true |
WithBot.addMonoidWithOne._proof_2 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u_1} [inst : AddMonoidWithOne α],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
RBTree.RBNode.Ordered.ins._f | Batteries.Recycling.RBTree.WF | ∀ {α : Type u_1} {cmp : α → α → Ordering} {x : α} (x_1 : RBTree.RBNode α)
(f :
RBTree.RBNode.below (motive := fun x_2 =>
RBTree.RBNode.Ordered cmp x_2 → RBTree.RBNode.Ordered cmp (RBTree.RBNode.ins cmp x x_2)) x_1),
RBTree.RBNode.Ordered cmp x_1 → RBTree.RBNode.Ordered cmp (RBTree.RBNode.ins cmp x x_1) | null | false |
Valuation.compatible_extension | Mathlib.Topology.Algebra.ValuativeRel.Completion | ∀ {K : Type u_2} {Γ₀ : Type u_3} [inst : Field K] [inst_1 : ValuativeRel K] [inst_2 : UniformSpace K]
[inst_3 : IsValuativeTopology K] [inst_4 : IsUniformAddGroup K] [inst_5 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) [inst_6 : v.Compatible], v.extension.Compatible | null | true |
AlgEquiv.toOpposite._proof_1 | Mathlib.Algebra.Algebra.Opposite | ∀ (A : Type u_1) [inst : CommSemiring A] (x y : A),
(RingEquiv.toOpposite A).toFun (x * y) = (RingEquiv.toOpposite A).toFun x * (RingEquiv.toOpposite A).toFun y | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget.vec | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} → (self : Std.Tactic.BVDecide.BVExpr.bitblast.ExtractTarget aig len) → aig.RefVec self.w | null | true |
Lean.Meta.SynthInstance.Answer.noConfusionType | Lean.Meta.SynthInstance | Sort u → Lean.Meta.SynthInstance.Answer → Lean.Meta.SynthInstance.Answer → Sort u | null | false |
SimpleGraph.edist_bot_of_ne | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {u v : V}, u ≠ v → ⊥.edist u v = ⊤ | null | true |
Polynomial.taylorEquiv.eq_1 | Mathlib.RingTheory.Polynomial.DegreeLT | ∀ {R : Type u_1} [inst : CommRing R] (r : R),
Polynomial.taylorEquiv r =
{ toFun := (↑↑(Polynomial.taylorAlgHom r).toRingHom).toFun, invFun := ⇑(Polynomial.taylorAlgHom (-r)),
left_inv := ⋯, right_inv := ⋯, map_mul' := ⋯, map_add' := ⋯, commutes' := ⋯ } | null | true |
String.singleton_ne_empty | Init.Data.String.Lemmas.Basic | ∀ {c : Char}, String.singleton c ≠ "" | null | true |
Equidecomp.ctorIdx | Mathlib.Algebra.Group.Action.Equidecomp | {X : Type u_1} → {G : Type u_2} → {inst : SMul G X} → Equidecomp X G → ℕ | null | false |
_private.Mathlib.GroupTheory.FreeGroup.Reduce.0.FreeGroup.toWord_mul_mk_eq._proof_1_34 | Mathlib.GroupTheory.FreeGroup.Reduce | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α) (b : Bool) (x : FreeGroup α) (i : ℕ),
¬(List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord ++ [(a, b)]).length ≤ i →
¬i + 1 ≤ (List.map ((fun g => (g.1, !g.2)) ∘ fun g => (g.1, !g.2)) x.toWord).length →
i - (List.map ((fun g => (g.1, !g.2)) ∘ fu... | null | false |
UInt16.xor_zero | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ^^^ 0 = a | null | true |
finrank_eq_one_iff_of_nonzero | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u} {V : Type v} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] (v : V),
v ≠ 0 → (Module.finrank K V = 1 ↔ K ∙ v = ⊤) | A vector space with a nonzero vector `v` has dimension 1 iff `v` spans.
| true |
PFunctor.M.iselect | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} → [DecidableEq F.A] → [Inhabited F.M] → PFunctor.Approx.Path F → F.M → F.A | similar to `isubtree` but returns the data at the end of the path instead
of the whole subtree | true |
AddActionHom.embMap._proof_1 | Mathlib.GroupTheory.GroupAction.MultipleTransitivity | ∀ (G : Type u_4) (α : Type u_2) [inst : AddGroup G] [inst_1 : AddAction G α] {m : Type u_3} {n : Type u_1} (e : m ↪ n)
(x : G) (x_1 : n ↪ α), e.trans (x +ᵥ x_1) = e.trans (x +ᵥ x_1) | null | false |
SimpleGraph.IsClique.finsetMap | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {β : Type u_2} {G : SimpleGraph α} {f : α ↪ β} {s : Finset α},
G.IsClique ↑s → (SimpleGraph.map (⇑f) G).IsClique ↑(Finset.map f s) | null | true |
Polynomial.polynomial_map_coe | Mathlib.RingTheory.PowerSeries.Basic | ∀ {U : Type u_2} {V : Type u_3} [inst : CommSemiring U] [inst_1 : CommSemiring V] {φ : U →+* V} {f : Polynomial U},
↑(Polynomial.map φ f) = (PowerSeries.map φ) ↑f | null | true |
AddMonCat.adj | Mathlib.Algebra.Category.MonCat.Adjunctions | AddMonCat.free ⊣ CategoryTheory.forget AddMonCat | The free-forgetful adjunction for additive monoids. | true |
Lean.Compiler.LCNF.MonadFVarSubst.recOn | Lean.Compiler.LCNF.CompilerM | {m : Type → Type} →
{pu : Lean.Compiler.LCNF.Purity} →
{translator : Bool} →
{motive : Lean.Compiler.LCNF.MonadFVarSubst m pu translator → Sort u} →
(t : Lean.Compiler.LCNF.MonadFVarSubst m pu translator) →
((getSubst : m (Lean.Compiler.LCNF.FVarSubst pu)) → motive { getSubst := getSubst }... | null | false |
Std.WP.ReaderT.instWPMonad._proof_3 | Std.WP.Monad.Instances | ∀ {m : Type u_1 → Type u_3} {EPred : Type u_4} {ρ : Type u_1} {Pred : Type u_2} [inst : Monad m]
[inst_1 : Std.WP.Assertion Pred] [inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred]
{α : Type u_1} (x : α) (post : α → ρ → Pred) (epost : EPred) (r : ρ),
Lean.Order.PartialOrder.rel (post x r) (S... | null | false |
_private.Std.Data.ExtTreeSet.Lemmas.0.Std.ExtTreeSet.mem_ofList._simp_1_1 | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(k ∈ t) = (t.contains k = true) | null | false |
CategoryTheory.Adjunction.whiskerLeftLCounitIsoOfIsIsoUnit_inv_app | Mathlib.CategoryTheory.Adjunction.FullyFaithful | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{L : CategoryTheory.Functor C D} {R : CategoryTheory.Functor D C} (h : L ⊣ R) [inst_2 : CategoryTheory.IsIso h.unit]
(X : C), h.whiskerLeftLCounitIsoOfIsIsoUnit.inv.app X = L.map (h.unit.app X) | null | true |
Action.resEquiv | Mathlib.CategoryTheory.Action.Basic | (V : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} V] →
{G : Type u_3} → {H : Type u_4} → [inst_1 : Monoid G] → [inst_2 : Monoid H] → G ≃* H → (Action V H ≌ Action V G) | Restricting scalars along a monoid isomorphism induces an equivalence of categories. | true |
Algebra.IsSeparable.recOn | Mathlib.FieldTheory.Separable | {F : Type u_1} →
{K : Type u_3} →
[inst : CommRing F] →
[inst_1 : Ring K] →
[inst_2 : Algebra F K] →
{motive : Algebra.IsSeparable F K → Sort u} →
(t : Algebra.IsSeparable F K) → ((isSeparable' : ∀ (x : K), IsSeparable F x) → motive ⋯) → motive t | null | false |
_private.Mathlib.RingTheory.Valuation.Integers.0.Valuation.term𝓞 | Mathlib.RingTheory.Valuation.Integers | Lean.ParserDescr | null | true |
CategoryTheory.PreOneHypercover.equivalenceMulticospanOfIso._proof_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {S : C} {E F : CategoryTheory.PreOneHypercover S}
(f : E ≅ F) (i : E.multicospanShape.L),
(CategoryTheory.Functor.id (CategoryTheory.Limits.WalkingMulticospan E.multicospanShape)).obj
(CategoryTheory.Limits.WalkingMulticospan.left i) =
((Categ... | null | false |
instIsAlgebraicMvPolynomialOfNoZeroDivisors_1 | Mathlib.RingTheory.Algebraic.Integral | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
[alg : Algebra.IsAlgebraic R S] {σ : Type u_4} [NoZeroDivisors S],
Algebra.IsAlgebraic (MvPolynomial σ R) (MvPolynomial σ S) | null | true |
Std.DHashMap.Raw.getKeyD_eq_fallback | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {a fallback : α}, a ∉ m → m.getKeyD a fallback = fallback | null | true |
Std.TreeMap.Raw.mem_toList_iff_getKey?_eq_some_and_getElem?_eq_some | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (k, v) ∈ t.toList ↔ t.getKey? k = some k ∧ t[k]? = some v | null | true |
_private.Mathlib.Algebra.Lie.Basis.Base.0.LieAlgebra.lieSpan_range_union_eq_top_of_mem_rootSpace._simp_1_1 | Mathlib.Algebra.Lie.Basis.Base | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) | null | false |
SSet.Edge.CompStruct.ofEq | Mathlib.AlgebraicTopology.SimplicialSet.CompStruct | {X : SSet} →
{x₀ x₁ x₂ y₀ y₁ y₂ : X.obj (Opposite.op { len := 0 })} →
{e₀₁ : SSet.Edge x₀ x₁} →
{f₀₁ : SSet.Edge y₀ y₁} →
{e₁₂ : SSet.Edge x₁ x₂} →
{f₁₂ : SSet.Edge y₁ y₂} →
{e₀₂ : SSet.Edge x₀ x₂} →
{f₀₂ : SSet.Edge y₀ y₂} →
e₀₁.CompStruct e₁₂ e₀₂... | Transports a `CompStruct` between edges `e₀₁`, `e₁₂` and `e₀₂` to a `CompStruct` between edges
`f₀₁`, `f₁₂` and `f₀₂` along equalities of 1-simplices `eᵢⱼ.edge = fᵢⱼ.edge`. | true |
Traversable.map_eq_traverse_id | Mathlib.Control.Traversable.Lemmas | ∀ {t : Type u → Type u} [inst : Traversable t] [LawfulTraversable t] {β γ : Type u} (f : β → γ),
Functor.map f = Id.run ∘ traverse (pure ∘ f) | null | true |
CategoryTheory.Limits.CatCospanTransform.category._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u_1} {B : Type u_6} {C : Type u_10} {A' : Type u_11} {B' : Type u_3} {C' : Type u_12}
[inst : CategoryTheory.Category.{u_4, u_1} A] [inst_1 : CategoryTheory.Category.{u_5, u_6} B]
[inst_2 : CategoryTheory.Category.{u_7, u_10} C] {F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B}
[inst_3... | null | false |
CategoryTheory.Limits.IsInitial.uniqueUpToIso_inv | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T T' : C} (hT : CategoryTheory.Limits.IsInitial T)
(hT' : CategoryTheory.Limits.IsInitial T'), (hT.uniqueUpToIso hT').inv = hT'.to T | null | true |
MvQPF.noConfusion | Mathlib.Data.QPF.Multivariate.Basic | {P : Sort u_2} →
{n : ℕ} →
{F : TypeVec.{u} n → Type u_1} →
{t : MvQPF F} →
{n' : ℕ} →
{F' : TypeVec.{u} n' → Type u_1} → {t' : MvQPF F'} → n = n' → F ≍ F' → t ≍ t' → MvQPF.noConfusionType P t t' | null | false |
Finset.notMem_map_subtype_of_not_property | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {p : α → Prop} (s : Finset { x // p x }) {a : α},
¬p a → a ∉ Finset.map (Function.Embedding.subtype fun x => p x) s | If a `Finset` of a subtype is converted to the main type with
`Embedding.subtype`, the result does not contain any value that does
not satisfy the property of the subtype. | true |
_private.Lean.Environment.0.Lean.VisibilityMap.public | Lean.Environment | {α : Type} → Lean.VisibilityMap✝ α → α | null | true |
Aesop.ElabRuleTerm.term | Aesop.RuleTac.RuleTerm | Lean.Term → Lean.Expr → Aesop.ElabRuleTerm | null | true |
CategoryTheory.Core.inclusion_obj | Mathlib.CategoryTheory.Core | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (self : CategoryTheory.Core C),
(CategoryTheory.Core.inclusion C).obj self = self.of | null | true |
monotone_iff_apply₂ | Mathlib.Order.Monotone.Defs | ∀ {ι : Type u_1} {α : Type u} {β : ι → Type u_4} [inst : (i : ι) → Preorder (β i)] [inst_1 : Preorder α]
{f : α → (i : ι) → β i}, Monotone f ↔ ∀ (i : ι), Monotone fun x => f x i | null | true |
ImportGraph.Shake.DeclNeeds.calcIRNeeds | ImportGraph.Shake.DeclNeeds | ImportGraph.Shake.DeclNeeds → ImportGraph.Shake.StanceM ImportGraph.Shake.DeclNeeds | Calculates the IR needs of a declaration. Currently ignores meta IR. | true |
Quiver.Path.toList_injective._f | Mathlib.Combinatorics.Quiver.Path | ∀ {V : Type u} [inst : Quiver V] [∀ (a b : V), Subsingleton (a ⟶ b)] (a x : V) (x_1 : Quiver.Path a x)
(f : Quiver.Path.below (motive := fun x x_2 => ∀ (x_3 : Quiver.Path a x), x_2.toList = x_3.toList → x_2 = x_3) x_1)
(x_2 : Quiver.Path a x), x_1.toList = x_2.toList → x_1 = x_2 | null | false |
ContDiffMapSupportedIn.postcompCLM._proof_1 | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {𝕜 : Type u_4} {E : Type u_2} {F : Type u_1} {F' : Type u_3} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace ℝ F]
[inst_5 : NormedSpace 𝕜 F] [inst_6 : SMulCommClass ℝ 𝕜 F] [inst_7 : NormedAddCommGroup F'] [inst... | null | false |
_private.Lean.Meta.LitValues.0.Lean.Meta.getRatValue?.getRatValueNum? | Lean.Meta.LitValues | Lean.Expr → Lean.MetaM (Option ℚ) | null | true |
Set.Nonempty.not_disjoint | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} {s t : Set α}, (s ∩ t).Nonempty → ¬Disjoint s t | **Alias** of the reverse direction of `Set.not_disjoint_iff_nonempty_inter`. | true |
MvPolynomial.finitePresentation_universalFactorizationMap | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k),
(MvPolynomial.universalFactorizationMap R n m k hn).FinitePresentation | null | true |
CategoryTheory.Subobject.sup_factors_of_factors_left | Mathlib.CategoryTheory.Subobject.Lattice | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasImages C]
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] {A B : C} {X Y : CategoryTheory.Subobject B} {f : A ⟶ B},
X.Factors f → (X ⊔ Y).Factors f | null | true |
CategoryTheory.RelCat.opEquivalence._proof_2 | Mathlib.CategoryTheory.Category.RelCat | ∀ (X : CategoryTheory.RelCat),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.RelCat.opFunctor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id CategoryTheory.RelCat)).hom.app X))
((CategoryTheory.Iso.refl (CategoryTheory.RelCat.unopFunctor.comp CategoryTheory.RelCat.opFunctor)).hom.ap... | null | false |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.Valid.nextn.match_1_1 | Batteries.Data.String.Lemmas | ∀ {m₁ m₂ : List Char} (motive : (x : Substring.Raw) → x.Valid → x.toString.toList = m₁ ++ m₂ → Prop) (x : Substring.Raw)
(x_1 : x.Valid) (x_2 : x.toString.toList = m₁ ++ m₂),
(∀ (x : Substring.Raw) (h : x.Valid) (e : x.toString.toList = m₁ ++ m₂), motive x h e) → motive x x_1 x_2 | null | false |
Equiv.Set.univPi | Mathlib.Logic.Equiv.Set | {α : Type u_3} → {β : α → Type u_4} → (s : (a : α) → Set (β a)) → ↑(Set.univ.pi s) ≃ ((a : α) → ↑(s a)) | The set `Set.pi Set.univ s` is equivalent to `Π a, s a`. | true |
MeasureTheory.L1.edist_def | Mathlib.MeasureTheory.Function.L1Space.AEEqFun | ∀ {α : Type u_1} {β : Type u_2} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup β]
(f g : ↥(MeasureTheory.Lp β 1 μ)), edist f g = ∫⁻ (a : α), edist (↑↑f a) (↑↑g a) ∂μ | null | true |
CategoryTheory.sheafSections | Mathlib.CategoryTheory.Sites.Sheaf | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
(J : CategoryTheory.GrothendieckTopology C) →
(A : Type u₂) →
[inst_1 : CategoryTheory.Category.{v₂, u₂} A] →
CategoryTheory.Functor Cᵒᵖ (CategoryTheory.Functor (CategoryTheory.Sheaf J A) A) | The sections of a sheaf (i.e. evaluation as a presheaf on `C`). | true |
PMF.bindOnSupport_pure | Mathlib.Probability.ProbabilityMassFunction.Monad | ∀ {α : Type u_1} (p : PMF α), (p.bindOnSupport fun a x => PMF.pure a) = p | null | true |
SimpleGraph.notMem_edgeSet_of_isDiag._simp_1 | Mathlib.Combinatorics.SimpleGraph.Basic | ∀ {V : Type u} (G : SimpleGraph V) {e : Sym2 V}, e.IsDiag → (e ∈ G.edgeSet) = False | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Maps.0.SimpleGraph.support_induce_subset_coe_preimage_support.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} (G : SimpleGraph V) (s : Set V) (x : ↑s) (motive : x ∈ (SimpleGraph.induce s G).support → Prop)
(x_1 : x ∈ (SimpleGraph.induce s G).support),
(∀ (v : ↑s) (hadj : (x, v) ∈ {(u, v) | (SimpleGraph.induce s G).Adj u v}), motive ⋯) → motive x_1 | null | false |
WeierstrassCurve.Jacobian.Point.noConfusion | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | {P : Sort u} →
{R : Type r} →
{inst : CommRing R} →
{W' : WeierstrassCurve.Jacobian R} →
{t : W'.Point} →
{R' : Type r} →
{inst' : CommRing R'} →
{W'' : WeierstrassCurve.Jacobian R'} →
{t' : W''.Point} →
R = R' → inst ≍ inst' → W'... | null | false |
Subgroup.isCyclic | Mathlib.GroupTheory.SpecificGroups.Cyclic.Subgroup | ∀ {α : Type u_1} [inst : Group α] [IsCyclic α] (H : Subgroup α), IsCyclic ↥H | null | true |
Nat.find_add | Mathlib.Data.Nat.Find | ∀ {n : ℕ} {p : ℕ → Prop} [inst : DecidablePred p] {hₘ : ∃ m, p (m + n)} {hₙ : ∃ n, p n},
n ≤ Nat.find hₙ → Nat.find hₘ + n = Nat.find hₙ | null | true |
ZeroHom.instSub | Mathlib.Algebra.Group.Hom.Basic | {M : Type u_2} → {N : Type u_3} → [inst : Zero M] → [inst_1 : SubtractionMonoid N] → Sub (ZeroHom M N) | Given two zero-preserving morphisms `f`, `g`,
`f - g` is the additive morphism sending `x` to `f x - g x`. | true |
Bool.and_not_self | Init.Data.Bool | ∀ (x : Bool), (x && !x) = false | null | true |
_private.Mathlib.Algebra.Star.SelfAdjoint.0.skewAdjoint.conjugate._simp_1_1 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : AddCommGroup R] [inst_1 : StarAddMonoid R] {x : R}, (x ∈ skewAdjoint R) = (star x = -x) | null | false |
AlgebraicGeometry.IsReduced.rec | Mathlib.AlgebraicGeometry.Properties | {X : AlgebraicGeometry.Scheme} →
{motive : AlgebraicGeometry.IsReduced X → Sort u} →
((component_reduced : ∀ (U : X.Opens), IsReduced ↑(X.presheaf.obj (Opposite.op U))) → motive ⋯) →
(t : AlgebraicGeometry.IsReduced X) → motive t | null | false |
AlgebraicGeometry.Scheme.instIsOverFstOverInferInstanceOverClassId | Mathlib.AlgebraicGeometry.Pullbacks | ∀ {M S : AlgebraicGeometry.Scheme} [inst : M.Over S],
AlgebraicGeometry.Scheme.Hom.IsOver (CategoryTheory.Limits.pullback.fst (M ↘ S) (CategoryTheory.CategoryStruct.id S))
S | null | true |
List.forIn'_nil | Init.Data.List.Control | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] {f : (a : α) → a ∈ [] → β → m (ForInStep β)}
{b : β}, forIn' [] b f = pure b | null | true |
BoolRing.hasForgetToBoolAlg._proof_2 | Mathlib.Algebra.Category.BoolRing | ∀ {X Y Z : BoolRing} (f : X ⟶ Y) (g : Y ⟶ Z),
BoolAlg.ofHom (BoolRing.Hom.hom (CategoryTheory.CategoryStruct.comp f g)).asBoolAlg =
CategoryTheory.CategoryStruct.comp (BoolAlg.ofHom (BoolRing.Hom.hom f).asBoolAlg)
(BoolAlg.ofHom (BoolRing.Hom.hom g).asBoolAlg) | null | false |
_private.Init.Data.UInt.Package.0.instLinearOrderPackageUInt8._proof_8 | Init.Data.UInt.Package | ∀ (a b : UInt8), a ≤ b → b ≤ a → a = b | null | false |
cfcₙ_sum._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Init.Data.List.Sort.Impl.0.List.MergeSort.Internal.mergeSortTR.run.eq_1 | Init.Data.List.Sort.Impl | ∀ {α : Type u_1} (le : α → α → Bool) (property : [].length = 0),
List.MergeSort.Internal.mergeSortTR.run✝ le ⟨[], property⟩ = [] | null | true |
WeierstrassCurve.Affine.Point.instAddCommGroup._proof_7 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Affine F} [inst_1 : DecidableEq F] (a : W.Point), 0 + a = a | null | false |
AddEquiv.val_neg_piAddUnits_symm_apply | Mathlib.Algebra.Group.Pi.Units | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → AddMonoid (M i)] (f : (i : ι) → AddUnits (M i)) (x : ι),
↑(-AddEquiv.piAddUnits.symm f) x = (f x).neg | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.FlatMap.0.Std.Iter.step_flatMapAfterM.match_3.eq_3 | Init.Data.Iterators.Lemmas.Combinators.FlatMap | ∀ {α₂ γ : Type u_1} {m : Type u_1 → Type u_2} [inst : Std.Iterator α₂ m γ] (it₂ : Std.IterM m γ)
(motive : it₂.Step → Sort u_3) (h : it₂.IsPlausibleStep Std.IterStep.done)
(h_1 :
(it₂' : Std.IterM m γ) →
(out : γ) → (h : it₂.IsPlausibleStep (Std.IterStep.yield it₂' out)) → motive ⟨Std.IterStep.yield it₂' ... | null | true |
CategoryTheory.RingObjCat.Hom | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.CartesianMonoidalCategory C] →
[inst_2 : CategoryTheory.BraidedCategory C] → CategoryTheory.RingObjCat C → CategoryTheory.RingObjCat C → Type v | A morphism of ring objects. | true |
MeasureTheory.Integrable.integral_norm_condKernel | Mathlib.Probability.Kernel.Disintegration.Integral | ∀ {α : Type u_1} {Ω : Type u_2} {F : Type u_4} {mα : MeasurableSpace α} [inst : MeasurableSpace Ω]
[inst_1 : StandardBorelSpace Ω] [inst_2 : Nonempty Ω] [inst_3 : NormedAddCommGroup F]
{ρ : MeasureTheory.Measure (α × Ω)} [inst_4 : MeasureTheory.IsFiniteMeasure ρ] {f : α × Ω → F},
MeasureTheory.Integrable f ρ → Me... | null | true |
Std.Http.Internal.Char.qdtext | Std.Http.Internal.Char | Char → Bool | qdtext = HTAB / SP / %x21 / %x23-5B / %x5D-7E
; ASCII-only variant (no obs-text).
| true |
Matrix.BlockTriangular.mul | Mathlib.LinearAlgebra.Matrix.Block | ∀ {α : Type u_1} {m : Type u_2} {R : Type v} {b : m → α} [inst : LinearOrder α] [inst_1 : Fintype m]
[inst_2 : NonUnitalNonAssocSemiring R] {M N : Matrix m m R},
M.BlockTriangular b → N.BlockTriangular b → (M * N).BlockTriangular b | null | true |
Order.cof_eq_one_iff | Mathlib.SetTheory.Cardinal.Cofinality.Basic | ∀ {α : Type u} [inst : Preorder α], Order.cof α = 1 ↔ ∃ x, IsTop x | null | true |
moduleTopology | Mathlib.Topology.Algebra.Module.ModuleTopology | (R : Type u_1) → [TopologicalSpace R] → (A : Type u_2) → [Add A] → [SMul R A] → TopologicalSpace A | The module topology, for a module `A` over a topological ring `R`. It's the finest topology
making addition and the `R`-action continuous, or equivalently the finest topology making `A`
into a topological `R`-module. More precisely it's the Inf of the set of
topologies with these properties; theorems `continuousSMul` a... | true |
Lean.instReprKVMap | Lean.Data.KVMap | Repr Lean.KVMap | null | true |
_private.Mathlib.Algebra.Order.GroupWithZero.Lex.0.MonoidWithZeroHom.snd_mono._simp_1_2 | Mathlib.Algebra.Order.GroupWithZero.Lex | ∀ {α : Type u_2} {β : Type u_3} [inst : LE α] [inst_1 : LE β] {x y : α × β}, (x ≤ y) = (x.1 ≤ y.1 ∧ x.2 ≤ y.2) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.