name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Internal.Raw.WFImp.mk._flat_ctor | Std.Data.DHashMap.Internal.Defs | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β},
Std.DHashMap.Internal.IsHashSelf m.buckets →
m.size = (Std.DHashMap.Internal.toListModel m.buckets).length →
Std.Internal.List.DistinctKeys (Std.DHashMap.Internal.toListModel m.buckets) → Std.DHashMap.Internal.R... | null | false |
CategoryTheory.Limits.SequentialProduct.functorMap_commSq_succ._proof_6 | Mathlib.CategoryTheory.Limits.Shapes.SequentialProduct | ∀ (n : ℕ), n < n + 1 | null | false |
HasDerivWithinAt.clog | Mathlib.Analysis.SpecialFunctions.Complex.LogDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ} {s : Set ℂ},
HasDerivWithinAt f f' s x → f x ∈ Complex.slitPlane → HasDerivWithinAt (fun t => Complex.log (f t)) (f' / f x) s x | null | true |
Lean.Lsp.TextDocumentSyncOptions.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{t t' : Lean.Lsp.TextDocumentSyncOptions} → t = t' → Lean.Lsp.TextDocumentSyncOptions.noConfusionType P t t' | null | false |
LinearEquiv.symmEquiv_apply_symm_apply | Mathlib.Algebra.Module.Equiv.Defs | ∀ {R : Type u_1} {S : Type u_6} {M : Type u_7} {M₂ : Type u_9} [inst : Semiring R] [inst_1 : Semiring S]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] {module_M : Module R M} {module_S_M₂ : Module S M₂}
{σ : R →+* S} {σ' : S →+* R} {re₁ : RingHomInvPair σ σ'} {re₂ : RingHomInvPair σ' σ} (e : M ≃ₛₗ[σ] M₂) (... | null | true |
List.alternatingProd._sunfold | Mathlib.Algebra.BigOperators.Group.List.Defs | {G : Type u_4} → [One G] → [Mul G] → [Inv G] → List G → G | null | false |
hasCardinalLT_iff_cardinal_mk_lt | Mathlib.SetTheory.Cardinal.HasCardinalLT | ∀ (X : Type u) (κ : Cardinal.{u}), HasCardinalLT X κ ↔ Cardinal.mk X < κ | null | true |
QuotientAddGroup.induction_on | Mathlib.GroupTheory.Coset.Defs | ∀ {α : Type u_1} [inst : AddGroup α] {s : AddSubgroup α} {C : α ⧸ s → Prop} (x : α ⧸ s), (∀ (z : α), C ↑z) → C x | null | true |
ProbabilityTheory.Kernel.compProd_of_not_isSFiniteKernel_left | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (κ : ProbabilityTheory.Kernel α β) (η : ProbabilityTheory.Kernel (α × β) γ),
¬ProbabilityTheory.IsSFiniteKernel κ → κ.compProd η = 0 | null | true |
FreeLieAlgebra.Rel.smulOfTower | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {S : Type u_1} [inst_1 : Monoid S] [inst_2 : DistribMulAction S R]
[IsScalarTower S R R] (t : S) (a b : FreeNonUnitalNonAssocAlgebra R X),
FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (t • a) (t • b) | null | true |
Associates.factors_subsingleton | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Subsingleton α]
{a : Associates α}, a.factors = ⊤ | null | true |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_1 | Mathlib.Topology.Bornology.Absorbs | ∀ {G₀ : Type u_1} {α : Type u_2} [inst : GroupWithZero G₀] [inst_1 : Bornology G₀] [inst_2 : MulAction G₀ α]
{s t : Set α}, Absorbs G₀ s t = ∀ᶠ (c : G₀) in Bornology.cobounded G₀, Set.MapsTo (fun x => c⁻¹ • x) t s | null | false |
ne_zero_of_map | Mathlib.Algebra.Group.Hom.Defs | ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
[ZeroHomClass F R S] {f : F} {x : R}, f x ≠ 0 → x ≠ 0 | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ne_intMin_of_msb_eq_false._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, 0 < w → w = 0 → False | null | false |
_private.Mathlib.Algebra.BigOperators.Intervals.0.Finset.sum_Ico_Ico_comm._proof_1_4 | Mathlib.Algebra.BigOperators.Intervals | ∀ (a b a_1 b_1 : ℕ), (a ≤ a_1 ∧ a_1 < b) ∧ a_1 ≤ b_1 ∧ b_1 < b → (a ≤ b_1 ∧ b_1 < b) ∧ a ≤ a_1 ∧ a_1 < b_1 + 1 | null | false |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.coe_closure_eq._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (M : Subsemigroup R),
AddSubmonoid.closure ↑M = M.nonUnitalSubsemiringClosure.toAddSubmonoid | null | false |
_private.Lean.Meta.Tactic.Cbv.TheoremsLookup.0.Lean.Meta.Sym.Simp.Theorems.insertMany | Lean.Meta.Tactic.Cbv.TheoremsLookup | Lean.Meta.Sym.Simp.Theorems → Array Lean.Meta.Sym.Simp.Theorem → Lean.Meta.Sym.Simp.Theorems | null | true |
Matrix.parabolicEigenvalue._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | (1 + 1).AtLeastTwo | null | false |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_mean_remainder_cauchy._simp_1_7 | Mathlib.Analysis.Calculus.Taylor | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | null | false |
USize.ofNatLT | Init.Prelude | (n : ℕ) → n < USize.size → USize | Converts a natural number to a `USize`. Requires a proof that the number is small enough to be
representable without overflow.
This function is overridden at runtime with an efficient implementation.
| true |
convexHull_eq_iInter | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) s = ⋂ t, ⋂ (_ : s ⊆ t), ⋂ (_ : Convex 𝕜 t), t | null | true |
PFun.fixInduction'._proof_2 | Mathlib.Data.PFun | ∀ {α : Type u_1} {β : Type u_2} {f : α →. β ⊕ α} {b : β} (a' : α),
b ∈ f.fix a' → ∀ (b' : β), Sum.inl b' ∈ f a' → Sum.inl b ∈ f a' | null | false |
isOpen_interior._simp_1 | Mathlib.Topology.Closure | ∀ {X : Type u} [inst : TopologicalSpace X] {s : Set X}, IsOpen (interior s) = True | null | false |
Order.Ideal.instInfSet | Mathlib.Order.Ideal | {P : Type u_1} → [inst : SemilatticeSup P] → [OrderBot P] → InfSet (Order.Ideal P) | null | true |
String.Slice.Pattern.Model.ForwardSliceSearcher.matchesAt_iff_splits | Init.Data.String.Lemmas.Pattern.String.Basic | ∀ {pat s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.MatchesAt pat pos ↔ ∃ t₁ t₂, pos.Splits t₁ (pat.copy ++ t₂) | null | true |
Plausible.InjectiveFunction.shrink._proof_1 | Mathlib.Testing.Plausible.Functions | ∀ {α : Type} (xs : List ((_ : α) × α)),
(List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) →
(List.map Sigma.snd xs).Nodup → (List.map Sigma.fst xs).Perm (List.map Sigma.snd xs) ∧ (List.map Sigma.snd xs).Nodup | null | false |
Lean.Parser.Tactic.case' | Init.Tactics | Lean.ParserDescr | `case'` is similar to the `case tag => tac` tactic, but does not ensure the goal
has been solved after applying `tac`, nor admits the goal if `tac` failed.
Recall that `case` closes the goal using `sorry` when `tac` fails, and
the tactic execution is not interrupted.
| true |
CategoryTheory.Coverage.mk.noConfusion | Mathlib.CategoryTheory.Sites.Coverage | {C : Type u_1} →
{inst : CategoryTheory.Category.{v_1, u_1} C} →
{P : Sort u} →
{toPrecoverage : CategoryTheory.Precoverage C} →
{pullback :
∀ ⦃X Y : C⦄ (f : Y ⟶ X),
∀ S ∈ toPrecoverage.coverings X, ∃ T ∈ toPrecoverage.coverings Y, T.FactorsThruAlong S f} →
{toPre... | null | false |
CategoryTheory.instHasLiftingPropertySnd | Mathlib.CategoryTheory.LiftingProperties.Limits | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {Y Z W : C} {g : Z ⟶ W} {t : Y ⟶ W}
[inst_1 : CategoryTheory.Limits.HasPullback g t] {T₁ T₂ : C} (p : T₁ ⟶ T₂) [CategoryTheory.HasLiftingProperty p g],
CategoryTheory.HasLiftingProperty p (CategoryTheory.Limits.pullback.snd g t) | null | true |
Batteries.Random.MersenneTwister.State.mk.injEq | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (data : Vector (BitVec cfg.wordSize) cfg.stateSize)
(index : Fin cfg.stateSize) (data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize) (index_1 : Fin cfg.stateSize),
({ data := data, index := index } = { data := data_1, index := index_1 }) = (data = data_1 ∧ index = ... | null | true |
PresheafOfModules.instAddCommGroupModuleColimit._aux_14 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] →
{R : CategoryTheory.Functor Cᵒᵖ RingCat} →
{cR : CategoryTheory.Limits.Cocone R} →
(hcR : CategoryTheory.Limits.IsColimit cR) →
{M : PresheafOfModules R} →
{cM : CategoryTheory.Limits.Cocone M.presheaf} →
... | null | false |
CategoryTheory.ihom.ev_coev_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
[inst_2 : CategoryTheory.Closed A] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj A B ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((Ca... | null | true |
Subsemiring.unop_eq_bot._simp_1 | Mathlib.Algebra.Ring.Subsemiring.MulOpposite | ∀ {R : Type u_2} [inst : NonAssocSemiring R] {S : Subsemiring Rᵐᵒᵖ}, (S.unop = ⊥) = (S = ⊥) | null | false |
MeasureTheory.Measure.addHaarScalarFactor_smul_congr | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} {A : Type u_2} [inst : Group G] [inst_1 : AddCommGroup A] [inst_2 : DistribMulAction G A]
[inst_3 : MeasurableSpace A] [inst_4 : TopologicalSpace A] [inst_5 : BorelSpace A] [inst_6 : IsTopologicalAddGroup A]
[LocallyCompactSpace A] [inst_8 : ContinuousConstSMul G A] (μ : MeasureTheory.Measure A) {ν... | null | true |
_private.Mathlib.Data.Multiset.Bind.0.Multiset.nodup_bind._simp_1_1 | Mathlib.Data.Multiset.Bind | ∀ {α : Type u} {β : Type v} {l₁ : List α} {f : α → List β},
(List.flatMap f l₁).Nodup = ((∀ x ∈ l₁, (f x).Nodup) ∧ List.Pairwise (Function.onFun List.Disjoint f) l₁) | null | false |
Aesop.ForwardRuleMatches.noConfusionType | Aesop.Tree.Data.ForwardRuleMatches | Sort u → Aesop.ForwardRuleMatches → Aesop.ForwardRuleMatches → Sort u | null | false |
MeasureTheory.IsStoppingTime.measurableSpace.congr_simp | Mathlib.Probability.Martingale.OptionalSampling | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f f_1 : MeasureTheory.Filtration ι m}
(e_f : f = f_1) {τ τ_1 : Ω → WithTop ι} (e_τ : τ = τ_1) (hτ : MeasureTheory.IsStoppingTime f τ),
hτ.measurableSpace = ⋯.measurableSpace | null | true |
CategoryTheory.Functor.PushoutObjObj.mapArrowRight_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.Arrow C₂}... | null | true |
_private.Mathlib.GroupTheory.ClassEquation.0.Group.nat_card_center_add_sum_card_noncenter_eq_card._simp_1_6 | Mathlib.GroupTheory.ClassEquation | ∀ {α : Type u} {s : Set α}, (¬s.Nontrivial) = s.Subsingleton | null | false |
cfc_le_one_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_1... | null | true |
Set.cast_ncard_sdiff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α} {R : Type u_3} [inst : AddGroupWithOne R],
s ⊆ t → t.Finite → ↑(t \ s).ncard = ↑t.ncard - ↑s.ncard | null | true |
Std.Http.URI.EncodedQueryString._sizeOf_inst | Std.Http.Data.URI.Encoding | (r : UInt8 → Bool) → SizeOf (Std.Http.URI.EncodedQueryString r) | null | false |
DFinsupp.instLocallyFiniteOrder | Mathlib.Data.DFinsupp.Interval | {ι : Type u_1} →
{α : ι → Type u_2} →
[DecidableEq ι] →
[(i : ι) → DecidableEq (α i)] →
[inst : (i : ι) → PartialOrder (α i)] →
[inst_1 : (i : ι) → Zero (α i)] → [(i : ι) → LocallyFiniteOrder (α i)] → LocallyFiniteOrder (Π₀ (i : ι), α i) | null | true |
Lean.Meta.Match.Pattern.applyFVarSubst._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.FVarSubst → Lean.Meta.Match.Pattern → Lean.Meta.Match.Pattern | null | false |
NonemptyFinLinOrd.mk | Mathlib.Order.Category.NonemptyFinLinOrd | (toLinOrd : LinOrd) → [nonempty : Nonempty ↑toLinOrd] → [fintype : Fintype ↑toLinOrd] → NonemptyFinLinOrd | null | true |
Function.Injective.addAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x),
Function.Injective.addAction f hf smul = { toVAdd := inst_2, add_vadd := ⋯, zero_vadd := ⋯ } | null | true |
Subring.toNonUnitalSubring | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} → [inst : NonAssocRing R] → Subring R → NonUnitalSubring R | Turn a `Subring` into a `NonUnitalSubring` by forgetting that it contains `1`. | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.deriv2_qaryEntropy._simp_1_3 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {p : Prop} [Decidable p], (¬¬p) = p | null | false |
_private.Init.Data.Format.Basic.0.Std.Format.WorkGroup | Init.Data.Format.Basic | Type | null | true |
instMonoidWithConvMatrix._proof_4 | Mathlib.LinearAlgebra.Matrix.WithConv | ∀ {m : Type u_3} {n : Type u_2} {α : Type u_1} [inst : Monoid α] (a : WithConv (Matrix m n α)), a * 1 = a | null | false |
Sym.cast._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ} (h : n = m), Function.LeftInverse (fun s => ⟨↑s, ⋯⟩) fun s => ⟨↑s, ⋯⟩ | null | false |
Submodule.starProjection_inner_eq_zero | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{K : Submodule 𝕜 E} [inst_3 : K.HasOrthogonalProjection] (v w : E), w ∈ K → inner 𝕜 (v - K.starProjection v) w = 0 | The characterization of the orthogonal projection. | true |
Lean.Meta.DefEqCacheKind | Lean.Meta.ExprDefEq | Type | null | true |
Lean.Elab.Term.Quotation.MatchResult.noConfusion | Lean.Elab.Quotation | {P : Sort u} →
{t t' : Lean.Elab.Term.Quotation.MatchResult} → t = t' → Lean.Elab.Term.Quotation.MatchResult.noConfusionType P t t' | null | false |
Finset.instFintypeSubtypeMemSubgroupInvMulSubgroup._simp_2 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α] (s t : Finset α), ↑s * ↑t = ↑(s * t) | null | false |
MulRingSeminormClass.toMonoidHomClass | Mathlib.Algebra.Order.Hom.Basic | ∀ {F : Type u_7} {α : outParam (Type u_8)} {β : outParam (Type u_9)} {inst : NonAssocRing α} {inst_1 : Semiring β}
{inst_2 : PartialOrder β} {inst_3 : FunLike F α β} [self : MulRingSeminormClass F α β], MonoidHomClass F α β | null | true |
HomologicalComplex.Hom.isIso_of_components | Mathlib.Algebra.Homology.HomologicalComplex | ∀ {ι : Type u_1} {V : Type u} [inst : CategoryTheory.Category.{v, u} V]
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {c : ComplexShape ι} {C₁ C₂ : HomologicalComplex V c}
(f : C₁ ⟶ C₂) [∀ (n : ι), CategoryTheory.IsIso (f.f n)], CategoryTheory.IsIso f | null | true |
_private.Lean.Meta.Tactic.Grind.EMatchTheorem.0.Lean.Meta.Grind.NormalizePattern.Context.symPrios | Lean.Meta.Tactic.Grind.EMatchTheorem | Lean.Meta.Grind.NormalizePattern.Context✝ → Lean.Meta.Grind.SymbolPriorities | null | true |
exists_seq_strictAnti_strictMono_tendsto | Mathlib.Topology.Order.IsLUB | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LinearOrder α] [OrderTopology α] [DenselyOrdered α]
[FirstCountableTopology α] {x y : α},
x < y →
∃ u v,
StrictAnti u ∧
StrictMono v ∧
(∀ (k : ℕ), u k ∈ Set.Ioo x y) ∧
(∀ (l : ℕ), v l ∈ Set.Ioo x y) ∧
(∀ (k ... | null | true |
Std.DHashMap.diff | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.DHashMap α β → Std.DHashMap α β → Std.DHashMap α β | Computes the difference of the given hash maps.
This function always iterates through the smaller map, so the expected runtime is
`O(min(m₁.size, m₂.size))`.
| true |
Turing.TM1to0.trAux.eq_6 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ) (s : Γ) (x : σ),
Turing.TM1to0.trAux M s Turing.TM1.Stmt.halt x = ((none, x), Turing.TM0.Stmt.write s) | null | true |
Asymptotics.IsLittleO.forall_isBigOWith | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {E : Type u_3} {F : Type u_4} [inst : Norm E] [inst_1 : Norm F] {f : α → E} {g : α → F} {l : Filter α},
f =o[l] g → ∀ ⦃c : ℝ⦄, 0 < c → Asymptotics.IsBigOWith c l f g | **Alias** of the forward direction of `Asymptotics.isLittleO_iff_forall_isBigOWith`.
---
Definition of `IsLittleO` in terms of `IsBigOWith`. | true |
MonomialOrder.div_set | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {B : Set (MvPolynomial σ R)},
(∀ b ∈ B, IsUnit (m.leadingCoeff b)) →
∀ (f : MvPolynomial σ R),
∃ g r,
f = (Finsupp.linearCombination (MvPolynomial σ R) fun b => ↑b) g + r ∧
(∀ (b : ↑B), m.toSyn (m.degree (↑b * g b)) ... | Division by a *set* of multivariate polynomials
whose leading coefficients are invertible with respect to a monomial order | true |
MvPowerSeries.lexOrder_eq_top_iff_eq_zero._simp_1 | Mathlib.RingTheory.MvPowerSeries.LexOrder | ∀ {σ : Type u_1} {R : Type u_2} [inst : Semiring R] [inst_1 : LinearOrder σ] [inst_2 : WellFoundedGT σ]
(φ : MvPowerSeries σ R), (φ.lexOrder = ⊤) = (φ = 0) | null | false |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeSigma.match_1.splitter | Batteries.Data.Fin.Coding | (n : ℕ) →
(f : Fin (n + 1) → ℕ) →
(motive : Fin (Fin.sum fun x => f x.succ) → Sort u_1) →
(x : Fin (Fin.sum fun x => f x.succ)) →
((k : ℕ) → (hk : k < Fin.sum fun x => f x.succ) → motive ⟨k, hk⟩) → motive x | null | true |
ContinuousMap.instNormedCommRing._proof_2 | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} [inst : TopologicalSpace α] {R : Type u_2} [inst_1 : NormedCommRing R] (a b : C(α, R)), a * b = b * a | null | false |
SSet.Subcomplex.N.mk | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplicesSubcomplex | {X : SSet} →
{A : X.Subcomplex} →
{n : ℕ} →
(x : X.obj (Opposite.op { len := n })) → x ∈ X.nonDegenerate n → x ∉ A.obj (Opposite.op { len := n }) → A.N | Constructor for the type of nondegenerate simplices which
do not belong to a given subcomplex of a simplicial set. | true |
AdjoinRoot.instGroupWithZero._proof_8 | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_1} [inst : Field K] {f : Polynomial K}, (Ideal.span {f}).IsTwoSided | null | false |
em | Mathlib.Logic.Basic | ∀ (p : Prop), p ∨ ¬p | **Alias** of `Classical.em`. | true |
Lean.Widget.DiffTag.ctorElimType | Lean.Widget.InteractiveCode | {motive : Lean.Widget.DiffTag → Sort u} → ℕ → Sort (max 1 u) | null | false |
sup_le_of_le_sdiff_left | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, b ≤ c \ a → a ≤ c → a ⊔ b ≤ c | null | true |
Lean.Grind.Linarith.Expr.denote | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Expr → α | null | true |
Mathlib.Tactic.Algebra.RingCompute.add | Mathlib.Tactic.Algebra.Basic | {u v : Lean.Level} →
{R : Q(Type u)} →
{A : Q(Type v)} →
{sR : Q(CommSemiring «$R»)} →
{sA : Q(CommSemiring «$A»)} →
(sAlg : Q(Algebra «$R» «$A»)) →
Mathlib.Tactic.Ring.Common.Cache sR →
{a b : Q(«$A»)} →
Mathlib.Tactic.Algebra.BaseType sAlg a →
... | Evaluate the sum of two normalized expressions in `R` using `ring`. | true |
PolynomialLaw.instAddCommMonoid._proof_4 | Mathlib.RingTheory.PolynomialLaw.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] (f : M →ₚₗ[R] N), ↑0 • f = 0 | null | false |
IntermediateField.LinearDisjoint.adjoin_rank_eq_rank_left_of_isAlgebraic | Mathlib.FieldTheory.LinearDisjoint | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A : IntermediateField F E}
{L : Type w} [inst_3 : Field L] [inst_4 : Algebra F L] [inst_5 : Algebra L E] [inst_6 : IsScalarTower F L E],
A.LinearDisjoint L →
Algebra.IsAlgebraic F ↥A ∨ Algebra.IsAlgebraic F L →
Module.... | If `A` and `L` are linearly disjoint over `F`, one of them is algebraic,
then `[L(A) : L] = [A : F]`. | true |
CategoryTheory.Limits.isLimitConeUnopOfCocone_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.isLimitConeUnop... | null | true |
TwoSidedIdeal.opOrderIso_apply | Mathlib.RingTheory.TwoSidedIdeal.Basic | ∀ {R : Type u_1} [inst : NonUnitalNonAssocRing R] (I : TwoSidedIdeal R), TwoSidedIdeal.opOrderIso I = I.op | null | true |
Finset.card_neg_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α}, (-s).card ≤ s.card | null | true |
Lean.Server.lookupStatefulLspRequestHandler | Lean.Server.Requests | String → BaseIO (Option Lean.Server.StatefulRequestHandler) | null | true |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.firstDiff_comm._simp_1_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {α : Sort u_1} {a b : α}, (a ≠ b) = (b ≠ a) | null | false |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.withDensity_apply_eq_zero'._simp_1_4 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Std.Do.SPred.bientails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊣⊢ₛ Q_2) = (P_2.down ↔ Q_2.down) | null | true |
Mathlib.Meta.NormNum.proveJacobiSym | Mathlib.Tactic.NormNum.LegendreSymbol | (ea : Q(ℤ)) → (eb : Q(ℕ)) → (er : Q(ℤ)) × Q(jacobiSym «$ea» «$eb» = «$er») | This evaluates `r := jacobiSym a b` and produces a proof term for the equality.
This is done by reducing to `r := jacobiSymNat (a % b) b`. | true |
Lean.SerialMessage.casesOn | Lean.Message | {motive : Lean.SerialMessage → Sort u} →
(t : Lean.SerialMessage) →
((toBaseMessage : Lean.BaseMessage String) →
(kind : Lean.Name) → motive { toBaseMessage := toBaseMessage, kind := kind }) →
motive t | null | false |
Std.ExtTreeSet.insertMany_nil | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp], t.insertMany [] = t | null | true |
_private.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.0.Lean.initFn._@.Lean.PrettyPrinter.Delaborator.TopDownAnalyze.1201310447._hygCtx._hyg.4 | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | IO (Lean.Option Bool) | null | false |
_private.Mathlib.Data.List.TakeDrop.0.List.span.loop_eq_take_drop | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (l₁ l₂ : List α),
List.span.loop p l₁ l₂ = (l₂.reverse ++ List.takeWhile p l₁, List.dropWhile p l₁) | null | true |
Ideal.count_associates_eq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {a a₀ x : R} {n : ℕ},
Prime x →
¬x ∣ a → a₀ = x ^ n * a → (Associates.mk (Ideal.span {x})).count (Associates.mk (Ideal.span {a₀})).factors = n | Variant of `UniqueFactorizationMonoid.count_normalizedFactors_eq` for associated Ideals. | true |
CategoryTheory.Kleisli.Adjunction.adj._proof_4 | Mathlib.CategoryTheory.Monad.Kleisli | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (T : CategoryTheory.Monad C) {X : C}
{Y Y' : CategoryTheory.Kleisli T} (f : (CategoryTheory.Kleisli.Adjunction.toKleisli T).obj X ⟶ Y) (g : Y ⟶ Y'),
{ toFun := fun f => f.of, invFun := fun f => { of := f }, left_inv := ⋯, right_inv := ⋯ }
(Categor... | null | false |
Std.DHashMap.mem_of_mem_filter | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} [EquivBEq α] [LawfulHashable α]
{f : (a : α) → β a → Bool} {k : α}, k ∈ Std.DHashMap.filter f m → k ∈ m | null | true |
Std.DTreeMap.Raw.get?_alter | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k k' : α} {f : Option (β k) → Option (β k)},
(t.alter k f).get? k' = if h : cmp k k' = Ordering.eq then cast ⋯ (f (t.get? k)) else t.get? k' | null | true |
ULift.mulAction._proof_1 | Mathlib.Algebra.Module.ULift | ∀ {R : Type u_2} {M : Type u_3} [inst : Monoid R] [inst_1 : MulAction R M] (x x_1 : ULift.{u_1, u_2} R) (b : M),
(x.down * x_1.down) • b = x.down • x_1.down • b | null | false |
Std.DTreeMap.Internal.Impl.Const.getD_diff_of_contains_eq_false_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {m₁ m₂ : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
(h₁ : m₁.WF),
m₂.WF →
∀ {k : α} {fallback : β},
Std.DTreeMap.Internal.Impl.contains k m₂ = false →
Std.DTreeMap.Internal.Impl.Const.getD (m₁.diff m₂ ⋯) k fallback =
Std.DTreeM... | null | true |
AddSubgroup.mk_le_mk._simp_1 | Mathlib.Algebra.Group.Subgroup.Defs | ∀ {G : Type u_1} [inst : AddGroup G] {s t : AddSubmonoid G} (h_neg : ∀ {x : G}, x ∈ s.carrier → -x ∈ s.carrier)
(h_neg' : ∀ {x : G}, x ∈ t.carrier → -x ∈ t.carrier),
({ toAddSubmonoid := s, neg_mem' := h_neg } ≤ { toAddSubmonoid := t, neg_mem' := h_neg' }) = (s ≤ t) | null | false |
GrpCat.groupObj._aux_17 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_1, u_3} J] →
(F : CategoryTheory.Functor J GrpCat) →
(j : J) → ℤ → (F.comp (CategoryTheory.forget GrpCat)).obj j → (F.comp (CategoryTheory.forget GrpCat)).obj j | null | false |
EReal.induction₂_symm | Mathlib.Data.EReal.Basic | ∀ {P : EReal → EReal → Prop},
(∀ {x y : EReal}, P x y → P y x) →
P ⊤ ⊤ →
(∀ (x : ℝ), 0 < x → P ⊤ ↑x) →
P ⊤ 0 →
(∀ x < 0, P ⊤ ↑x) →
P ⊤ ⊥ →
(∀ (x : ℝ), 0 < x → P ↑x ⊥) →
(∀ (x y : ℝ), P ↑x ↑y) → P 0 ⊥ → (∀ x < 0, P ↑x ⊥) → P ⊥ ⊥ → ∀ (x y : EReal), P... | Induct on two `EReal`s by performing case splits on the sign of one whenever the other is
infinite. This version eliminates some cases by assuming that the relation is symmetric. | true |
CategoryTheory.MonoidalCategory.Limits.pushout.associator_naturality_left_condition_assoc | Mathlib.CategoryTheory.Monoidal.Limits.Shapes.Pullback | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.Limits.HasPushouts C] {A B X Y Z W : C} {f : A ⟶ B} {g : X ⟶ Y}
{h : CategoryTheory.MonoidalCategoryStruct.tensorObj Z W ⟶ X} {Z_1 : C}
(h_1 :
CategoryTheory.Limits.pushout (CategoryT... | null | true |
MDifferentiableOn.clm_bundle_apply₂ | Mathlib.Geometry.Manifold.VectorBundle.Hom | ∀ {𝕜 : Type u_1} {B : Type u_2} {F₁ : Type u_3} {F₂ : Type u_4} {F₃ : Type u_5} {M : Type u_6}
[inst : NontriviallyNormedField 𝕜] {E₁ : B → Type u_7} [inst_1 : (x : B) → AddCommGroup (E₁ x)]
[inst_2 : (x : B) → Module 𝕜 (E₁ x)] [inst_3 : NormedAddCommGroup F₁] [inst_4 : NormedSpace 𝕜 F₁]
[inst_5 : Topological... | Consider differentiable maps `v : M → E₁` and `v : M → E₂` to vector bundles, over a base map
`b : M → B`, and bilinear maps `ψ m : E₁ (b m) → E₂ (b m) → E₃ (b m)` depending smoothly on `m`.
One can apply `ψ m` to `v m` and `w m`, and the resulting map is differentiable.
We give here a version of this statement on a ... | true |
LightProfinite.instInhabited._proof_3 | Mathlib.Topology.Category.LightProfinite.Basic | SecondCountableTopology PEmpty.{u_1 + 1} | null | false |
_private.Mathlib.Data.Finset.Filter.0.Finset.filter_nonempty_iff._simp_1_4 | Mathlib.Data.Finset.Filter | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.