name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Asymptotics.IsEquivalent | Mathlib.Analysis.Asymptotics.AsymptoticEquivalent | {α : Type u_1} → {β : Type u_2} → [NormedAddCommGroup β] → Filter α → (α → β) → (α → β) → Prop | Two functions `u` and `v` are said to be asymptotically equivalent along a filter `l`
(denoted as `u ~[l] v` in the `Asymptotics` namespace)
when `u x - v x = o(v x)` as `x` converges along `l`. | true |
AffineSubspace.subtype_linear | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] (s : AffineSubspace k P) [inst_4 : Nonempty ↥s], s.subtype.linear = s.direction.subtype | null | true |
_private.Batteries.Data.List.Basic.0.List.next?.match_1.eq_2 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (l : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (l : List α) → motive (a :: l)),
(match a :: l with
| [] => h_1 ()
| a :: l => h_2 a l) =
h_2 a l | null | true |
Set.mulIndicator_eq_one_or_self | Mathlib.Algebra.Notation.Indicator | ∀ {α : Type u_1} {M : Type u_3} [inst : One M] (s : Set α) (f : α → M) (a : α),
s.mulIndicator f a = 1 ∨ s.mulIndicator f a = f a | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.ErrorContext.recOn | Mathlib.Tactic.Linter.TextBased | {motive : Mathlib.Linter.TextBased.ErrorContext✝ → Sort u} →
(t : Mathlib.Linter.TextBased.ErrorContext✝) →
((error : Mathlib.Linter.TextBased.StyleError✝) →
(lineNumber : ℕ) →
(path : System.FilePath) → motive { error := error, lineNumber := lineNumber, path := path }) →
motive t | null | false |
_private.Init.Data.Nat.ToString.0.Nat.length_toDigits_le_iff._simp_1_4 | Init.Data.Nat.ToString | ∀ {n : ℕ}, (n ≠ 0) = (0 < n) | null | false |
RBTree.RBSet.upperBoundP?_exists | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {t : RBTree.RBSet α cmp} [Std.TransCmp cmp]
[RBTree.RBNode.IsCut cmp cut], (∃ x, t.upperBoundP? cut = some x) ↔ ∃ x ∈ t, cut x ≠ Ordering.gt | null | true |
Lean.Elab.Tactic.RCases.instCoeIdentTSyntaxConsSyntaxNodeKindMkStr1Nil_lean | Lean.Elab.Tactic.RCases | Coe Lean.Ident (Lean.TSyntax `rcasesPat) | null | true |
ContinuousMultilinearMap.norm_mkPiAlgebraFin_zero | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {A : Type u_1} [inst_1 : SeminormedRing A]
[inst_2 : NormedAlgebra 𝕜 A], ‖ContinuousMultilinearMap.mkPiAlgebraFin 𝕜 0 A‖ = ‖1‖ | null | true |
FirstOrder.Ring.genericPolyMap.eq_1 | Mathlib.RingTheory.MvPolynomial.FreeCommRing | ∀ {ι : Type u_1} {κ : Type u_2} (monoms : ι → Finset (κ →₀ ℕ)) (i : ι),
FirstOrder.Ring.genericPolyMap monoms i =
∑ m ∈ (monoms i).attach, FreeCommRing.of (Sum.inl ⟨i, m⟩) * (↑m).prod fun j n => FreeCommRing.of (Sum.inr j) ^ n | null | true |
_private.Mathlib.Algebra.Order.Ring.WithTop.0.WithTop.pow_right_strictMono.match_1_1 | Mathlib.Algebra.Order.Ring.WithTop | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0),
(∀ (h : 0 ≠ 0), motive 0 h) →
(∀ (x : 1 ≠ 0), motive 1 x) → (∀ (n : ℕ) (x : n + 2 ≠ 0), motive n.succ.succ x) → motive x x_1 | null | false |
Sylow.normal_of_normalizerCondition | Mathlib.GroupTheory.Sylow | ∀ {G : Type u} [inst : Group G],
NormalizerCondition G → ∀ {p : ℕ} [Fact (Nat.Prime p)] [Finite (Sylow p G)] (P : Sylow p G), (↑P).Normal | null | true |
ContinuousAddMonoidHom.instAddCommMonoid._proof_1 | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {A : Type u_1} {E : Type u_2} [inst : AddMonoid A] [inst_1 : TopologicalSpace A] [inst_2 : AddCommMonoid E]
[inst_3 : TopologicalSpace E] [inst_4 : ContinuousAdd E] (x : A →ₜ+ E), 0 • x = 0 | null | false |
CategoryTheory.CommRingObjCat.instCategory._proof_2 | Mathlib.CategoryTheory.Monoidal.Ring | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X Y Z : CategoryTheory.CommRingObjCat C} (f : X.Hom Y) (g : Y.Hom Z),
CategoryTheory.IsRingHom (CategoryTheory.CategoryStruct.comp f.hom g.hom) | null | false |
NNReal.coe_real_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ↑NNReal.pi = Real.pi | null | true |
FiniteDimensional.RCLike.properSpace_submodule | Mathlib.Analysis.RCLike.Lemmas | ∀ (K : Type u_1) {E : Type u_2} [inst : RCLike K] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(S : Submodule K E) [FiniteDimensional K ↥S], ProperSpace ↥S | null | true |
IsPrimitiveRoot.neZero' | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {R : Type u_4} {ζ : R} [inst : CommRing R] [IsDomain R] {n : ℕ} [NeZero n], IsPrimitiveRoot ζ n → NeZero ↑n | null | true |
MeasureTheory.setIntegral_indicatorConstLp | Mathlib.MeasureTheory.Integral.Bochner.Set | ∀ {X : Type u_1} {E : Type u_3} {mX : MeasurableSpace X} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
{s t : Set X} {μ : MeasureTheory.Measure X} [CompleteSpace E] {p : ENNReal},
MeasurableSet s →
∀ (ht : MeasurableSet t) (hμt : μ t ≠ ⊤) (e : E),
∫ (x : X) in s, ↑↑(MeasureTheory.indicatorConst... | null | true |
Polynomial.degree_map_le | Mathlib.Algebra.Polynomial.Eval.Degree | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] {f : R →+* S} {p : Polynomial R},
(Polynomial.map f p).degree ≤ p.degree | null | true |
LinearMap.flip._proof_5 | Mathlib.LinearAlgebra.BilinearMap | ∀ {R : Type u_6} {R₂ : Type u_7} {S : Type u_3} {S₂ : Type u_4} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : Semiring S] [inst_3 : Semiring S₂] {M : Type u_5} {N : Type u_2} {P : Type u_1} [inst_4 : AddCommMonoid M]
[inst_5 : AddCommMonoid N] [inst_6 : AddCommMonoid P] [inst_7 : Module R M] [inst_8 : Module... | null | false |
AddSemiconjBy.map._simp_1 | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {a x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddSemiconjBy a x y → ∀ (f : F), AddSemiconjBy (f a) (f x) (f y) = True | null | false |
_private.Mathlib.Tactic.Ring.Basic.0.Mathlib.Tactic.Ring.RingCompute.pow._proof_1 | Mathlib.Tactic.Ring.Basic | ∀ {b : Q(ℕ)} (lit : Q(ℕ)), «$b» =Q «$lit» | null | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_14 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → x :: y :: tail ≠ [] | null | false |
_private.Lean.Meta.Tactic.Replace.0.Lean.MVarId.withReverted.match_1 | Lean.Meta.Tactic.Replace | (motive : Option Lean.FVarId → Sort u_1) →
(x? : Option Lean.FVarId) → ((x : Lean.FVarId) → motive (some x)) → ((x : Option Lean.FVarId) → motive x) → motive x? | null | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Equiv.toList_eq._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Order.IsPredLimit.ne_top | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} {a : α} [inst : Preorder α] [inst_1 : OrderTop α], Order.IsPredLimit a → a ≠ ⊤ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.size_left_le_size_union._simp_1_3 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : Ord α} {t : Std.DTreeMap.Internal.Impl α β} {k : α},
(k ∈ t) = (Std.DTreeMap.Internal.Impl.contains k t = true) | null | false |
_private.Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion.0.aux_IsBigO_mul | Mathlib.NumberTheory.ModularForms.EisensteinSeries.QExpansion | ∀ (k l : ℕ) (p : ℝ) {f : ℕ → ℂ},
(f =O[Filter.atTop] fun n => ↑n ^ l) →
(fun n => f n * (2 * ↑Real.pi * Complex.I * ↑n / ↑p) ^ k) =O[Filter.atTop] fun n => ↑(n ^ (l + k)) | null | true |
ProbabilityTheory.Kernel.compProd_prodMkLeft_eq_comp | Mathlib.Probability.Kernel.Composition.KernelLemmas | ∀ {X : Type u_1} {Y : Type u_2} {Z : Type u_3} {mX : MeasurableSpace X} {mY : MeasurableSpace Y}
{mZ : MeasurableSpace Z} (κ : ProbabilityTheory.Kernel X Y) [ProbabilityTheory.IsSFiniteKernel κ]
(η : ProbabilityTheory.Kernel Y Z) [ProbabilityTheory.IsSFiniteKernel η],
κ.compProd (ProbabilityTheory.Kernel.prodMkLe... | null | true |
Subgroup.Commensurable.commensurator._proof_4 | Mathlib.GroupTheory.Commensurable | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G) {x : G},
x ∈ {g | (MulAut.conj g • H).Commensurable H} → x⁻¹ ∈ {g | (MulAut.conj g • H).Commensurable H} | null | false |
MonadSatisfying.instStateRefT'._proof_2 | Batteries.Recycling.MonadSatisfying.Basic | ∀ {m : Type → Type} {ω σ : Type} [inst : Monad m] [LawfulMonad m], LawfulFunctor (StateRefT' ω σ m) | null | false |
BEq.rfl | Init.Core | ∀ {α : Type u_1} [inst : BEq α] [ReflBEq α] {a : α}, (a == a) = true | null | true |
IsLUB | Mathlib.Order.Bounds.Defs | {α : Type u_1} → [LE α] → Set α → α → Prop | `a` is a least upper bound of a set `s`; for a partial order, it is unique if exists. | true |
_private.Lean.Meta.CongrTheorems.0.Lean.Meta.mkCongrSimpCore?.mkProof.go._unsafe_rec | Lean.Meta.CongrTheorems | Array Lean.Meta.CongrArgKind → ℕ → Lean.Expr → Lean.MetaM Lean.Expr | null | false |
_private.Mathlib.Analysis.ODE.ExistUnique.0.ODE_solution_unique_univ._proof_1_2 | Mathlib.Analysis.ODE.ExistUnique | ∀ {t₀ : ℝ} (t : ℝ),
t ∈ Set.Ioo (min (-|t|) (-|t₀|) - 1) (max |t| |t₀| + 1) ∧ t₀ ∈ Set.Ioo (min (-|t|) (-|t₀|) - 1) (max |t| |t₀| + 1) | null | false |
Multiset.instDistribLattice | Mathlib.Data.Multiset.UnionInter | {α : Type u_1} → [DecidableEq α] → DistribLattice (Multiset α) | null | true |
AbstractMeasure.diracHom | Mathlib.NumberTheory.Padics.Measure.Monoid | {G : Type u_1} →
{R : Type u_2} →
[inst : TopologicalSpace G] →
[inst_1 : CommRing R] →
[inst_2 : TopologicalSpace R] →
[inst_3 : IsTopologicalRing R] →
[inst_4 : Monoid G] →
[inst_5 : ContinuousMul G] → [inst_6 : LocallyCompactSpace G] → G →* AbstractMeasure G R ... | The Dirac map `G → D(G, R)`, packaged as a multiplicative homomorphism. | true |
_private.Mathlib.RingTheory.AdjoinRoot.0.AdjoinRoot.map._simp_1 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u} {S : Type v} {T : Type w} [inst : Semiring R] {p : Polynomial R} [inst_1 : Semiring S] (f : R →+* S)
[inst_2 : Semiring T] (g : S →+* T) (x : T),
Polynomial.eval₂ (g.comp f) x p = Polynomial.eval₂ g x (Polynomial.map f p) | null | false |
ENat.smul_sSup | Mathlib.Data.ENat.Lattice | ∀ {R : Type u_4} [inst : SMul R ℕ∞] [IsScalarTower R ℕ∞ ℕ∞] (s : Set ℕ∞) (c : R), c • sSup s = ⨆ a ∈ s, c • a | null | true |
Preorder.piCongrLeft_comp_restrictLe | Mathlib.Order.Restriction | ∀ {α : Type u_1} [inst : Preorder α] {π : α → Type u_2} [inst_1 : LocallyFiniteOrderBot α] {a : α},
⇑(Equiv.piCongrLeft (fun i => π ↑i) (Equiv.IicFinsetSet a).symm) ∘ Preorder.restrictLe a = Preorder.frestrictLe a | null | true |
Part.get_eq_get_of_eq | Mathlib.Data.Part | ∀ {α : Type u_1} (a : Part α) (ha : a.Dom) {b : Part α} (h : a = b), a.get ha = b.get ⋯ | null | true |
IntermediateField.adjoin_simple_add_algebraMap | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E] (x : E) (y : F),
F⟮x + (algebraMap F E) y⟯ = F⟮x⟯ | Adjoining `x + algebraMap F E y`, where `y` lies in the base field, yields the same simple
extension as adjoining `x`. | true |
_private.Lean.Elab.Import.0.Lean.Elab.printImports.match_1 | Lean.Elab.Import | (motive : Array Lean.Import × Lean.Position × Lean.MessageLog → Sort u_1) →
(x : Array Lean.Import × Lean.Position × Lean.MessageLog) →
((deps : Array Lean.Import) → (fst : Lean.Position) → (snd : Lean.MessageLog) → motive (deps, fst, snd)) → motive x | null | false |
CategoryTheory.Arrow.leftFunc_obj | Mathlib.CategoryTheory.Comma.Arrow | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Arrow C),
CategoryTheory.Arrow.leftFunc.obj X = X.left | null | true |
String.Slice.Pattern.Model.ForwardStringSearcher.isLongestRevMatch_iff | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat : String} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch pat pos ↔ (s.sliceFrom pos).copy = pat | null | true |
Filter.Realizer.ofEquiv_F | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_1} {τ : Type u_4} {f : Filter α} (F : f.Realizer) (E : F.σ ≃ τ) (s : τ),
(F.ofEquiv E).F.f s = F.F.f (E.symm s) | null | true |
_private.Mathlib.AlgebraicTopology.ExtraDegeneracy.0.CategoryTheory.SimplicialObject.Augmented.ExtraDegeneracy.homotopy._proof_33 | Mathlib.AlgebraicTopology.ExtraDegeneracy | ∀ {n : ℕ} (i : Fin (n + 2)) (j k : Fin (n + 1)) (hk : j.rev = k) (l : ℕ) (hl : ↑i = ↑j + 1 + l),
↑i = ↑⟨l + 1, ⋯⟩ + ↑j.castSucc | null | false |
CategoryTheory.GrothendieckTopology.PreservesSheafification.transport | Mathlib.CategoryTheory.Sites.Equivalence | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] (K : CategoryTheory.GrothendieckTopology D)
(G : CategoryTheory.Functor D C) {A : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} A] (B : Type u₄)
... | null | true |
CategoryTheory.RanIsSheafOfIsCocontinuous.liftAux._proof_1 | Mathlib.CategoryTheory.Sites.CoverLifting | ∀ {C : Type u_1} {D : Type u_4} [inst : CategoryTheory.Category.{u_2, u_1} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {G : CategoryTheory.Functor C D}
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D} [G.IsCocontinuous J K] {X : D}
{S : K.Cover X} {Y : C} (f : G.obj Y... | null | false |
IntermediateField.lift_relrank_comap_comap_eq_lift_relrank_of_surjective | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {L : Type w} [inst_3 : Field L]
[inst_4 : Algebra F L] (A B : IntermediateField F E) (f : L →ₐ[F] E),
Function.Surjective ⇑f →
Cardinal.lift.{v, w} ((IntermediateField.comap f A).relrank (IntermediateField.comap f B)) =
... | null | true |
_private.Mathlib.Data.Set.Image.0.Set.imageFactorization_surjective.match_1_1 | Mathlib.Data.Set.Image | ∀ {α : Type u_2} {β : Type u_1} {f : α → β} {s : Set α} (motive : ↑(f '' s) → Prop) (x : ↑(f '' s)),
(∀ (a : α) (ha : a ∈ s), motive ⟨f a, ⋯⟩) → motive x | null | false |
iSup_inf_eq | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Frame α] (f : ι → α) (a : α), (⨆ i, f i) ⊓ a = ⨆ i, f i ⊓ a | null | true |
Lean.Parser.Term.throwNamedErrorMacro | Lean.Parser.Term | Lean.Parser.Parser | Throws an error exception, tagging the associated message as a named error with the specified name
and validating that an associated error explanation exists. The message may be passed as an
interpolated string or a `MessageData` term. The result of `getRef` is used as position information.
| true |
Complex.UnitClosedDisc.mk_inj._simp_1 | Mathlib.Analysis.Complex.UnitDisc.Basic | ∀ {z w : ℂ} (hz : ‖z‖ ≤ 1) (hw : ‖w‖ ≤ 1), (Complex.UnitClosedDisc.mk z hz = Complex.UnitClosedDisc.mk w hw) = (z = w) | null | false |
QuaternionAlgebra.coe_natCast | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} {c₁ c₂ c₃ : R} [inst : AddCommGroupWithOne R] (n : ℕ), ↑↑n = ↑n | null | true |
_private.Mathlib.RingTheory.TensorProduct.MvPolynomial.0.MvPolynomial.coeff_rTensorAlgEquiv_tmul._simp_1_2 | Mathlib.RingTheory.TensorProduct.MvPolynomial | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_5} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {S : Type u_9}
[inst_3 : Semiring S] [inst_4 : Module R S] [inst_5 : SMulCommClass R S S] (s : S) (m : M), s • 1 ⊗ₜ[R] m = s ⊗ₜ[R] m | null | false |
CategoryTheory.IndParallelPairPresentation.parallelPairIsoParallelPairCompYoneda._proof_4 | Mathlib.CategoryTheory.Limits.Indization.ParallelPair | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {A B : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{f g : A ⟶ B} (P : CategoryTheory.IndParallelPairPresentation f g),
CategoryTheory.Limits.HasColimit
(((CategoryTheory.Functor.whiskeringRight P.I C (CategoryTheory.Functor Cᵒᵖ (Type u_1))).obj
... | null | false |
Std.Sat.AIG.RefVec.MapTarget.recOn | Std.Sat.AIG.RefVecOperator.Map | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{len : ℕ} →
{motive : Std.Sat.AIG.RefVec.MapTarget aig len → Sort u} →
(t : Std.Sat.AIG.RefVec.MapTarget aig len) →
((vec : aig.RefVec len) →
(func : (aig : Std... | null | false |
Std.Async.BaseAsync.instMonad | Std.Async.Basic | Monad Std.Async.BaseAsync | null | true |
Std.DTreeMap.Internal.Impl.getKeyD_union!_of_contains_eq_false_left | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k fallback : α},
Std.DTreeMap.Internal.Impl.contains k m₁ = false → (m₁.union! m₂).getKeyD k fallback = m₂.getKeyD k fallback | null | true |
Sat.Fmla.reify.mk | Mathlib.Tactic.Sat.FromLRAT | ∀ {v : Sat.Valuation} {f : Sat.Fmla} {p : Prop}, (¬v.satisfies_fmla f → p) → Sat.Fmla.reify v f p | null | true |
Std.ExtHashMap.ext_getKey_getElem?_iff | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} [inst : EquivBEq α] [inst_1 : LawfulHashable α]
{m₁ m₂ : Std.ExtHashMap α β},
m₁ = m₂ ↔ (∀ (k : α) (hk : k ∈ m₁) (hk' : k ∈ m₂), m₁.getKey k hk = m₂.getKey k hk') ∧ ∀ (k : α), m₁[k]? = m₂[k]? | null | true |
CategoryTheory.Limits.spanCompIso._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z)
{X_1 Y_1 : CategoryTheory.Limits.WalkingSpan} (f_1 : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp (((CategoryTheory.L... | null | false |
Lean.Elab.TerminationMeasure.mk.noConfusion | Lean.Elab.PreDefinition.TerminationMeasure | {P : Sort u} →
{ref : Lean.Syntax} →
{structural : Bool} →
{fn : Lean.Expr} →
{ref' : Lean.Syntax} →
{structural' : Bool} →
{fn' : Lean.Expr} →
{ ref := ref, structural := structural, fn := fn } =
{ ref := ref', structural := structural', fn := f... | null | false |
Lean.Elab.MonadParentDecl.noConfusionType | Lean.Elab.InfoTree.Types | Sort u → {m : Type → Type} → Lean.Elab.MonadParentDecl m → {m' : Type → Type} → Lean.Elab.MonadParentDecl m' → Sort u | null | false |
CategoryTheory.Abelian.Ext.bilinearComp | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Abelian C] →
[inst_2 : CategoryTheory.HasExt C] →
(X Y Z : C) →
(a b c : ℕ) →
a + b = c →
CategoryTheory.Abelian.Ext X Y a →+ CategoryTheory.Abelian.Ext Y Z b →+ CategoryTheory.Abe... | The composition of `Ext`, as a bilinear map. | true |
BialgHom.toAlgHom._proof_2 | Mathlib.RingTheory.Bialgebra.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : CoalgebraStruct R A] [inst_6 : CoalgebraStruct R B]
(f : A →ₐc[R] B), f.toLinearMap 0 = 0 | null | false |
Lean.Meta.Match.State.mk.injEq | Lean.Meta.Match.Match | ∀ (used : Std.HashSet ℕ) (overlaps : Lean.Meta.Match.Overlaps) (counterExamples : Array (List Lean.Meta.Match.Example))
(used_1 : Std.HashSet ℕ) (overlaps_1 : Lean.Meta.Match.Overlaps)
(counterExamples_1 : Array (List Lean.Meta.Match.Example)),
({ used := used, overlaps := overlaps, counterExamples := counterExam... | null | true |
CategoryTheory.Limits.preservesProduct_of_preservesBiproduct | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {D : Type u'}
[inst_2 : CategoryTheory.Category.{v', u'} D] [inst_3 : CategoryTheory.Preadditive D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] {J : Type u_1} [Finite J] {f : J → C}
[CategoryT... | A functor between preadditive categories that preserves (zero morphisms and) finite biproducts
preserves finite products. | true |
QuadraticAlgebra.range_lift | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_2} {a b : R} [inst : CommSemiring R] {A : Type u_3} [inst_1 : Ring A] [inst_2 : Algebra R A] {u : A}
(h : u * u = a • 1 + b • u), (QuadraticAlgebra.lift ⟨u, h⟩).range = R[u] | The range of `lift ⟨u, h⟩` is the subalgebra of `A` generated by `u`. | true |
countableSupClosure_eq_self._simp_2 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_2} {s : Set α} [inst : Preorder α], (countableSupClosure s = s) = CountableSupClosed s | null | false |
ENat.coe_lt_coe | Mathlib.Data.ENat.Basic | ∀ {n m : ℕ}, ↑n < ↑m ↔ n < m | **Alias** of `ENat.natCast_lt_natCast`. | true |
CategoryTheory.CountableAB4Star.of_hasExactLimitsOfShape_nat | Mathlib.CategoryTheory.Abelian.GrothendieckAxioms.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[CategoryTheory.Limits.HasFiniteBiproducts C] [CategoryTheory.Limits.HasFiniteColimits C]
[inst_4 : CategoryTheory.Limits.HasCountableProducts C]
[CategoryTheory.HasExactLimitsOfShape (CategoryTheory.Discr... | Checking exact limits of shape `Discrete ℕ` is enough for countable AB4\*, provided that the
category has finite biproducts and finite colimits.
| true |
Std.ExtHashMap.getElem?_filter' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : LawfulBEq α]
{f : α → β → Bool} {k : α}, (Std.ExtHashMap.filter f m)[k]? = Option.filter (f k) m[k]? | Simpler variant of `getElem?_filter` when `LawfulBEq` is available. | true |
_private.Lean.Parser.Command.0.Lean.Parser.Term.quot._regBuiltin.Lean.Parser.Term.quot.formatter_9 | Lean.Parser.Command | IO Unit | null | false |
IsAzumaya.recOn | Mathlib.Algebra.Azumaya.Defs | {R : Type u_1} →
{A : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Algebra R A] →
{motive : IsAzumaya R A → Sort u} →
(t : IsAzumaya R A) →
([toProjective : Module.Projective R A] →
[toFaithfulSMul : FaithfulSMul R A] →... | null | false |
CommMonoidWithZero.zero_mul | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [self : CommMonoidWithZero M₀] (a : M₀), 0 * a = 0 | Zero is a left absorbing element for multiplication | true |
Frm.hom_ext_iff | Mathlib.Order.Category.Frm | ∀ {X Y : Frm} {f g : X ⟶ Y}, f = g ↔ Frm.Hom.hom f = Frm.Hom.hom g | null | true |
Nat.choose_mul_factorial_mul_factorial | Mathlib.Data.Nat.Choose.Basic | ∀ {n k : ℕ}, k ≤ n → n.choose k * k.factorial * (n - k).factorial = n.factorial | null | true |
Subring.op_top | Mathlib.Algebra.Ring.Subring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocRing R], ⊤.op = ⊤ | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.mem_lattice._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {x y z : M},
(z ∈ Submodule.span R {x, y}) = ∃ a b, a • x + b • y = z | null | false |
ZFSet.Definable | Mathlib.SetTheory.ZFC.Basic | (n : ℕ) → ((Fin n → ZFSet.{u}) → ZFSet.{u}) → Type (u + 1) | A set function is "definable" if it is the image of some n-ary `PSet`
function. This isn't exactly definability, but is useful as a sufficient
condition for functions that have a computable image. | true |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.toFunctorToCategoricalPullback._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u_3} {B : Type u_6} {C : Type u_4} [inst : CategoryTheory.Category.{u_1, u_3} A]
[inst_1 : CategoryTheory.Category.{u_5, u_6} B] [inst_2 : CategoryTheory.Category.{u_2, u_4} C]
(F : CategoryTheory.Functor A B) (G : CategoryTheory.Functor C B) (X : Type u_8)
[inst_3 : CategoryTheory.Category.{u_7, u_8}... | null | false |
Finset.notMem_singleton | Mathlib.Data.Finset.Insert | ∀ {α : Type u_1} {a b : α}, a ∉ {b} ↔ a ≠ b | null | true |
Plausible.SampleableExt.sample | Plausible.Sampleable | {α : Sort u} → [self : Plausible.SampleableExt α] → Plausible.Arbitrary (Plausible.SampleableExt.proxy α) | null | true |
NNReal.coe_sInf | Mathlib.Basic.NNReal.Defs | ∀ (s : Set NNReal), ↑(sInf s) = sInf (NNReal.toReal '' s) | null | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.instRxcLawfulHasSize.match_5 | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ (motive : (n : ℕ) → BitVec n → BitVec n → BitVec n → Prop) (n : ℕ) (lo hi lo_1 : BitVec n),
(∀ (lo hi lo_2 : BitVec 0), motive 0 lo hi lo_2) →
(∀ (n : ℕ) (lo hi lo_2 : BitVec (n + 1)), motive n.succ lo hi lo_2) → motive n lo hi lo_1 | null | false |
Measurable.of_discrete | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [DiscreteMeasurableSpace α]
{f : α → β}, Measurable f | null | true |
_private.Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional.0.ContinuousLinearMap.im_apply_eq_zero_of_tendsto_nhds_opNorm._simp_1_4 | Mathlib.Analysis.CStarAlgebra.PositiveLinearFunctional | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
LinearEquiv.toContinuousLinearEquivOfBounds | Mathlib.Analysis.Normed.Operator.ContinuousLinearMap | {𝕜 : Type u_1} →
{𝕜₂ : Type u_2} →
{E : Type u_3} →
{F : Type u_4} →
[inst : Ring 𝕜] →
[inst_1 : Ring 𝕜₂] →
[inst_2 : SeminormedAddCommGroup E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : Module 𝕜 E] →
[inst_5 : Module ... | Construct a continuous linear equivalence from a linear equivalence together with
bounds in both directions. | true |
_private.Mathlib.Analysis.SumIntegralComparisons.0.integral_le_sum_mul_Ico_of_antitone_monotone._proof_1_3 | Mathlib.Analysis.SumIntegralComparisons | ∀ {a b : ℕ} (i : ℕ), ↑a ≤ ↑i ∧ ↑i + 1 ≤ ↑b → ↑a - 1 ∈ Set.Icc (↑a - 1) (↑b - 1) | null | false |
Std.Http.Body.Empty.ctorIdx | Std.Http.Data.Body.Empty | Std.Http.Body.Empty → ℕ | null | false |
Lean.Compiler.LCNF.Simp.ConstantFold.Folder.leftRightAnnihilator._auto_1 | Lean.Compiler.LCNF.Simp.ConstantFold | Lean.Syntax | null | false |
UniformEquiv.piCongrRight | Mathlib.Topology.UniformSpace.Equiv | {ι : Type u_4} →
{β₁ : ι → Type u_5} →
{β₂ : ι → Type u_6} →
[inst : (i : ι) → UniformSpace (β₁ i)] →
[inst_1 : (i : ι) → UniformSpace (β₂ i)] → ((i : ι) → β₁ i ≃ᵤ β₂ i) → ((i : ι) → β₁ i) ≃ᵤ ((i : ι) → β₂ i) | `Equiv.piCongrRight` as a uniform isomorphism: this is the natural isomorphism
`Π i, β₁ i ≃ᵤ Π j, β₂ i` obtained from uniform isomorphisms `β₁ i ≃ᵤ β₂ i` for each `i`. | true |
AlgebraicGeometry.Scheme.isAffine_affineBasisCover | Mathlib.AlgebraicGeometry.AffineScheme | ∀ (X : AlgebraicGeometry.Scheme) (i : X.affineBasisCover.I₀), AlgebraicGeometry.IsAffine (X.affineBasisCover.X i) | null | true |
Array.append_inj_left' | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs₁ xs₂ ys₁ ys₂ : Array α}, xs₁ ++ ys₁ = xs₂ ++ ys₂ → ys₁.size = ys₂.size → xs₁ = xs₂ | Variant of `append_inj_left` instead requiring equality of the sizes of the second arrays. | true |
not_covBy_bot._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : Preorder α] [inst_1 : OrderBot α] {a : α}, (a ⋖ ⊥) = False | null | false |
RingHomInvPair.mk._flat_ctor | Mathlib.Algebra.Ring.CompTypeclasses | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ : R₁ →+* R₂}
{σ' : outParam (R₂ →+* R₁)}, σ'.comp σ = RingHom.id R₁ → σ.comp σ' = RingHom.id R₂ → RingHomInvPair σ σ' | null | false |
MeasureTheory.AddQuotientMeasureEqMeasurePreimage.addHaarMeasure_quotient | Mathlib.MeasureTheory.Measure.Haar.Quotient | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : MeasurableSpace G] [inst_2 : TopologicalSpace G]
[IsTopologicalAddGroup G] [BorelSpace G] [PolishSpace G] {Γ : AddSubgroup G} [inst_6 : Γ.Normal] [T2Space (G ⧸ Γ)]
[SecondCountableTopology (G ⧸ Γ)] {μ : MeasureTheory.Measure (G ⧸ Γ)} [Countable ↥Γ] (ν : MeasureTheory.M... | If a measure `μ` on the quotient `G ⧸ Γ` of an additive group `G` by a discrete
normal subgroup `Γ` having fundamental domain, satisfies `AddQuotientMeasureEqMeasurePreimage`
relative to a standardized choice of Haar measure on `G`, and assuming `μ` is finite, then `μ` is
itself Haar. | true |
LightDiagram.diagram | Mathlib.Topology.Category.LightProfinite.Basic | LightDiagram → CategoryTheory.Functor ℕᵒᵖ FintypeCat | The indexing diagram. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.