name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Order.Filter.FilterProduct.0.Filter.Germ.coe_lt._simp_1_4 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {f : Ultrafilter α} {p : α → Prop}, (∀ᶠ (x : α) in ↑f, ¬p x) = ¬∀ᶠ (x : α) in ↑f, p x | null | false |
CategoryTheory.mateEquiv_conjugateEquiv_vcomp | Mathlib.CategoryTheory.Adjunction.Mates | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {D : Type u₄} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.Category.{v₄, u₄} D] {G : CategoryTheory.Functor A C} {H : CategoryTheory.Functor B D}
{L₁ : Ca... | The mates equivalence commutes with this composition, essentially by `mateEquiv_vcomp`. | true |
NumberField.mixedEmbedding.unitSMul_smul | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.FundamentalCone | ∀ (K : Type u_1) [inst : Field K] (u : (NumberField.RingOfIntegers K)ˣ) (x : NumberField.mixedEmbedding.mixedSpace K),
u • x = (NumberField.mixedEmbedding K) ((algebraMap (NumberField.RingOfIntegers K) K) ↑u) * x | null | true |
BitVec.smod_eq | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w),
x.smod y =
match x.msb, y.msb with
| false, false => x.umod y
| false, true =>
have u := x.umod (-y);
if u = 0#w then u else u + y
| true, false =>
have u := (-x).umod y;
if u = 0#w then u else y - u
| true, true => -(-x).umod (-y) | Equation theorem for `smod` in terms of `umod`. | true |
spectrum.subset_subalgebra | Mathlib.Algebra.Algebra.Spectrum.Basic | ∀ {S : Type u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Ring A] [inst_2 : Algebra R A]
[inst_3 : SetLike S A] [inst_4 : SubringClass S A] [inst_5 : SMulMemClass S R A] {s : S} (a : ↥s),
spectrum R ↑a ⊆ spectrum R a | null | true |
IsPrimitiveRoot.isIntegral | Mathlib.RingTheory.RootsOfUnity.Minpoly | ∀ {n : ℕ} {K : Type u_1} [inst : CommRing K] {μ : K}, IsPrimitiveRoot μ n → 0 < n → IsIntegral ℤ μ | `μ` is integral over `ℤ`. | true |
Equiv.nonUnitalCommSemiring._proof_1 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalCommSemiring β], e (e.symm 0) = 0 | null | false |
QPF.fixToW._proof_1 | Mathlib.Data.QPF.Univariate.Basic | ∀ {F : Type u_1 → Type u_1} [q : QPF F] (x y : (QPF.P F).W),
QPF.Wequiv x y → QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) x = QPF.recF (fun x => PFunctor.W.mk (QPF.repr x)) y | null | false |
FiberBundleCore.localTrivAsPartialEquiv_target | Mathlib.Topology.FiberBundle.Basic | ∀ {ι : Type u_1} {B : Type u_2} {F : Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
(Z : FiberBundleCore ι B F) (i : ι), (Z.localTrivAsPartialEquiv i).target = (Z.localTriv i).target | null | true |
_private.Mathlib.CategoryTheory.Filtered.Basic.0.CategoryTheory.IsFiltered.cocone_nonempty._simp_1_4 | Mathlib.CategoryTheory.Filtered.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_excenter_singleton_eq._proof_1_4 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {V : Type u_2} {P : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] (t : Affine.Triangle ℝ P) {i₁ i₃ : Fin 3},
i₁ ≠ i₃ → ∃ x, ¬x = i₃ ∧ t.points x = t.points i₁ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt.0.CFC.conjSqrt_ringInverse_conjSqrt._proof_1_3 | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.ConjSqrt | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [inst_8 : SeparatelyContinuousMul A] [IsSemitopologicalRing ... | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt64.zero_shiftLeft._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt64}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Lean.Omega.IntList.gcd_eq_zero._simp_1 | Init.Omega.IntList | ∀ {xs : Lean.Omega.IntList}, (xs.gcd = 0) = ∀ x ∈ xs, x = 0 | null | false |
Ring.DirectLimit.lift_of | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) (i : ι) (x : G i),
(Ring.DirectLimit.lift G f P g... | null | true |
_private.Lean.Meta.InferType.0.Lean.Meta.ArrowPropResult.casesOn | Lean.Meta.InferType | {motive : Lean.Meta.ArrowPropResult✝ → Sort u} →
(t : Lean.Meta.ArrowPropResult✝) →
motive Lean.Meta.ArrowPropResult.false✝ →
motive Lean.Meta.ArrowPropResult.true✝ →
motive Lean.Meta.ArrowPropResult.undef✝ → ((idx : ℕ) → motive (Lean.Meta.ArrowPropResult.bvar✝ idx)) → motive t | null | false |
CategoryTheory.Monad.monadicOfHasPreservesReflexiveCoequalizersOfReflectsIsomorphisms._proof_1 | Mathlib.CategoryTheory.Monad.Monadicity | ∀ {C : Type u_3} {D : Type u_2} [inst : CategoryTheory.Category.{u_1, u_3} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] {G : CategoryTheory.Functor D C} {F : CategoryTheory.Functor C D}
(adj : F ⊣ G) [CategoryTheory.Limits.HasReflexiveCoequalizers D] [G.ReflectsIsomorphisms]
[CategoryTheory.Monad.PreservesC... | null | false |
sigmaFinsuppEquivDFinsupp_symm_apply | Mathlib.Data.Finsupp.ToDFinsupp | ∀ {ι : Type u_1} {η : ι → Type u_4} {N : Type u_5} [inst : Zero N] (f : Π₀ (i : ι), η i →₀ N) (s : (i : ι) × η i),
(sigmaFinsuppEquivDFinsupp.symm f) s = (f s.fst) s.snd | null | true |
_private.Batteries.Data.Array.Lemmas.0.Array.extract_append_of_stop_le_size_left._proof_1_14 | Batteries.Data.Array.Lemmas | ∀ {α : Type u_1} {j i : ℕ} {a b : Array α}, j ≤ a.size → (a ++ b).extract i j = a.extract i j | null | false |
UInt8.ofBitVec_shiftRight_mod | Init.Data.UInt.Bitwise | ∀ (a : BitVec 8) (b : ℕ), { toBitVec := a >>> (b % 8) } = { toBitVec := a } >>> UInt8.ofNat b | null | true |
Std.Time.TimeZone.convertTZif | Std.Time.Zoned.Database.Basic | Std.Time.TimeZone.TZif.TZif → String → Except String Std.Time.TimeZone.ZoneRules | Converts a `TZif.TZif` structure to a `ZoneRules` structure.
| true |
_private.Lean.Data.Json.FromToJson.Basic.0.Lean.Json.Structured.toJson.match_1 | Lean.Data.Json.FromToJson.Basic | (motive : Lean.Json.Structured → Sort u_1) →
(x : Lean.Json.Structured) →
((a : Array Lean.Json) → motive (Lean.Json.Structured.arr a)) →
((o : Std.TreeMap.Raw String Lean.Json compare) → motive (Lean.Json.Structured.obj o)) → motive x | null | false |
CategoryTheory.SmallObject.SuccStruct.isColimitIterationCocone | Mathlib.CategoryTheory.SmallObject.TransfiniteIteration | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(Φ : CategoryTheory.SmallObject.SuccStruct C) →
(J : Type w) →
[inst_1 : LinearOrder J] →
[inst_2 : OrderBot J] →
[inst_3 : SuccOrder J] →
[inst_4 : WellFoundedLT J] →
[inst_5 : CategoryThe... | `Φ.iteration J` identifies to the colimit of `Φ.iterationFunctor J`. | true |
ULift.group._proof_6 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u_2} [inst : Group α] (x : ULift.{u_1, u_2} α) (x_1 : ℤ), Equiv.ulift (x ^ x_1) = Equiv.ulift (x ^ x_1) | null | false |
WithBot.unbotD_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] (d : α), WithBot.unbotD d 0 = 0 | null | true |
_private.Mathlib.Data.Fin.SuccPred.0.Fin.succAbove_succAbove_succAbove_predAbove._proof_1_11 | Mathlib.Data.Fin.SuccPred | ∀ {n : ℕ} (i : Fin (n + 2)) (j : Fin (n + 1)) (k : Fin n),
↑j < ↑i → ¬↑k < ↑i - 1 → ¬↑k + 1 < ↑j → ↑k < ↑j → ↑k < ↑i → ↑k + 1 + 1 = ↑k | null | false |
HomologicalComplex.cylinder.map_ι₁_mapHomologicalComplexObjIso_hom | Mathlib.Algebra.Homology.HomotopyCofiber | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C] {ι : Type u_2}
{c : ComplexShape ι} (F : HomologicalComplex C c) [inst_2 : DecidableRel c.Rel] {D : Type u_3}
[inst_3 : CategoryTheory.Category.{v_2, u_3} D] [inst_4 : CategoryTheory.Preadditive D]
(H : Category... | null | true |
BddAbove.smul_of_nonpos | Mathlib.Algebra.Order.Module.Pointwise | ∀ {α : Type u_1} {β : Type u_2} [inst : Ring α] [inst_1 : PartialOrder α] [IsOrderedRing α] [inst_3 : AddCommGroup β]
[inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : Module α β] [PosSMulMono α β] {s : Set β} {a : α},
a ≤ 0 → BddAbove s → BddBelow (a • s) | null | true |
Orientation.norm_div_tan_oangle_sub_left_of_oangle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.RightAngle | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [hd2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, o.oangle x y = ↑(Real.pi / 2) → ‖y‖ / (o.oangle (x - y) x).tan = ‖x‖ | A side of a right-angled triangle divided by the tangent of the opposite angle equals the
adjacent side, version subtracting vectors. | true |
NumberField.instCommRingInfiniteAdeleRing._aux_32 | Mathlib.NumberTheory.NumberField.InfiniteAdeleRing | (K : Type u_1) →
[inst : Field K] → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K → NumberField.InfiniteAdeleRing K | null | false |
ValuationRing.instOfIsLocalRingOfIsBezout | Mathlib.RingTheory.Valuation.ValuationRing | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsLocalRing R] [IsBezout R], ValuationRing R | null | true |
RingHom.SurjectiveOnStalks.baseChange | Mathlib.RingTheory.SurjectiveOnStalks | ∀ {R : Type u_1} [inst : CommRing R] {S : Type u_2} [inst_1 : CommRing S] {T : Type u_3} [inst_2 : CommRing T]
[inst_3 : Algebra R T] [inst_4 : Algebra R S],
(algebraMap R T).SurjectiveOnStalks → (algebraMap S (TensorProduct R S T)).SurjectiveOnStalks | null | true |
Int.bmod_eq_of_le_mul_two | Init.Data.Int.DivMod.Lemmas | ∀ {x : ℤ} {y : ℕ}, -↑y ≤ x * 2 → x * 2 < ↑y → x.bmod y = x | null | true |
Commute.conj | Mathlib.Algebra.Group.Commute.Basic | ∀ {G : Type u_1} [inst : Group G] {a b : G}, Commute a b → ∀ (h : G), Commute (h * a * h⁻¹) (h * b * h⁻¹) | null | true |
lp.instNormedSpace._proof_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_1} {α : Type u_3} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedField 𝕜]
[inst_2 : (i : α) → NormedSpace 𝕜 (E i)] (i : α), IsBoundedSMul 𝕜 (E i) | null | false |
ContinuousAffineMap.toContinuousMap_coe | Mathlib.Topology.Algebra.ContinuousAffineMap | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {P : Type u_4} {Q : Type u_5} [inst : Ring R] [inst_1 : AddCommGroup V]
[inst_2 : Module R V] [inst_3 : TopologicalSpace P] [inst_4 : AddTorsor V P] [inst_5 : AddCommGroup W]
[inst_6 : Module R W] [inst_7 : TopologicalSpace Q] [inst_8 : AddTorsor W Q] (f : P →ᴬ[R] Q), ... | null | true |
Int.neg_le_neg | Init.Data.Int.Order | ∀ {a b : ℤ}, a ≤ b → -b ≤ -a | null | true |
CategoryTheory.GrothendieckTopology.Cover.Arrow.precomp_Y | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} (I : S.Arrow) {Z : C} (g : Z ⟶ I.Y), (I.precomp g).Y = Z | null | true |
_private.Mathlib.Topology.QuasiSeparated.0.QuasiSeparatedSpace.isCompact_sInter_of_nonempty._proof_1_6 | Mathlib.Topology.QuasiSeparated | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set (Set α)},
s = {t | t ∈ s ∧ IsOpen t} ∪ {t | t ∈ s ∧ IsClosed t} → {t | t ∈ s ∧ IsOpen t} ⊆ s | null | false |
Lean.Parser.Tactic.Conv.pattern | Init.Conv | Lean.ParserDescr | * `pattern pat` traverses to the first subterm of the target that matches `pat`.
* `pattern (occs := *) pat` traverses to every subterm of the target that matches `pat`
which is not contained in another match of `pat`. It generates one subgoal for each matching
subterm.
* `pattern (occs := 1 2 4) pat` matches occur... | true |
Fin.xor_self | Mathlib.Data.Fin.Init | ∀ {k : ℕ} [inst : NeZero k] (a : Fin k), a ^^^ a = 0 | null | true |
_private.Mathlib.RingTheory.OreLocalization.NonZeroDivisors.0.OreLocalization.inv._simp_2 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {a : Prop}, (a ∨ a) = a | null | false |
instModuleGradedTensorProduct._proof_4 | Mathlib.LinearAlgebra.TensorProduct.Graded.Internal | ∀ (R : Type u_1) {ι : Type u_2} {A : Type u_3} {B : Type u_4} [inst : CommSemiring ι] [inst_1 : DecidableEq ι]
[inst_2 : CommRing R] [inst_3 : Ring A] [inst_4 : Ring B] [inst_5 : Algebra R A] [inst_6 : Algebra R B]
(𝒜 : ι → Submodule R A) (ℬ : ι → Submodule R B) [inst_7 : GradedAlgebra 𝒜] [inst_8 : GradedAlgebra ... | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic.0.IsSlice | Mathlib.ModelTheory.Arithmetic.Presburger.Semilinear.Basic | {M : Type u_1} → [Add M] → Set M → Prop | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey?_insertIfNew_le_minKey?._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 |
_private.Mathlib.CategoryTheory.Generator.Basic.0.CategoryTheory.ObjectProperty.IsCoseparating.of_equivalence._simp_1_1 | Mathlib.CategoryTheory.Generator.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v_1, u₁} C] {D : Type u₂}
[inst_1 : CategoryTheory.Category.{v_2, u₂} D] (F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
{W : D} (h : F.obj Z ⟶ W),
CategoryTheory.CategoryStruct.comp (F.map f) (CategoryTheory.CategoryStruct.comp (F.map g) h) =
... | null | false |
LinearOrder.supClosed._simp_2 | Mathlib.Order.SupClosed | ∀ {α : Type u_3} [inst : LinearOrder α] (s : Set α), SupClosed s = True | null | false |
Option.bind.match_1 | Init.Data.Option.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : Option α → (α → Option β) → Sort u_3) →
(x : Option α) →
(x_1 : α → Option β) →
((x : α → Option β) → motive none x) → ((a : α) → (f : α → Option β) → motive (some a) f) → motive x x_1 | null | false |
CategoryTheory.Functor.PreservesEffectiveEpis.recOn | Mathlib.CategoryTheory.EffectiveEpi.Preserves | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
{motive : F.PreservesEffectiveEpis → Sort u} →
(t : F.PreservesEffectiveEpis) →
((preserves :
... | null | false |
OrderHom.instBotOfOrderBot | Mathlib.Order.Hom.Order | {α : Type u_1} → {β : Type u_2} → [inst : Preorder α] → [inst_1 : Preorder β] → [OrderBot β] → Bot (α →o β) | null | true |
Mathlib.Tactic.ClickSuggestions.spawnTask | Mathlib.Tactic.ClickSuggestions.SectionState | {α : Type} →
Mathlib.Tactic.ClickSuggestions.Premise →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM α →
Mathlib.Tactic.ClickSuggestions.ClickSuggestionsM (Task (Except ProofWidgets.Html (Option α))) | Spawn a task that computes a piece of `Html` to be displayed when finished. | true |
Real.logb_nonpos_iff' | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 1 < b → 0 ≤ x → (Real.logb b x ≤ 0 ↔ x ≤ 1) | null | true |
List.tailD_nil | Init.Data.List.Basic | ∀ {α : Type u} {l' : List α}, [].tailD l' = l' | null | true |
EuclideanGeometry.Sphere.mk_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {P : Type u_2} [inst : MetricSpace P] (c : P) (r : ℝ), { center := c, radius := r }.center = c | null | true |
SymAlg.instOne.eq_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : One α], SymAlg.instOne = { one := SymAlg.sym 1 } | null | true |
MvPolynomial.quotientEquivQuotientMvPolynomial._proof_1 | Mathlib.RingTheory.Polynomial.Quotient | ∀ {R : Type u_1} {σ : Type u_2} [inst : CommRing R] (I : Ideal R), (Ideal.map MvPolynomial.C I).IsTwoSided | null | false |
FP.Float.isFinite._sparseCasesOn_1 | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] →
{motive : FP.Float → Sort u} →
(t : FP.Float) →
((a : Bool) → (e : ℤ) → (m : ℕ) → (a_1 : FP.ValidFinite e m) → motive (FP.Float.finite a e m a_1)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
RingQuot.definition._proof_3._@.Mathlib.Algebra.RingQuot.1624853203._hygCtx._hyg.2 | Mathlib.Algebra.RingQuot | ∀ (S : Type u_3) [inst : CommSemiring S] {A : Type u_1} [inst_1 : Semiring A] [inst_2 : Algebra S A] {B : Type u_2}
[inst_3 : Semiring B] [inst_4 : Algebra S B] {s : A → A → Prop} (f : { f // ∀ ⦃x y : A⦄, s x y → f x = f y }),
(fun F => ⟨F.comp (RingQuot.mkAlgHom S s), ⋯⟩) ((fun f' => RingQuot.preLiftAlgHom S ⋯) f)... | null | false |
CategoryTheory.Equivalence.congrLeft._proof_5 | Mathlib.CategoryTheory.Equivalence | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_6, u_5} C] {D : Type u_1}
[inst_1 : CategoryTheory.Category.{u_4, u_1} D] {E : Type u_3} [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
(e : C ≌ D) (F : CategoryTheory.Functor C E),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Functor.whiskeringLe... | null | false |
Std.DTreeMap.Const.getD_alter | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} [Std.TransCmp cmp] {k k' : α}
{fallback : β} {f : Option β → Option β},
Std.DTreeMap.Const.getD (Std.DTreeMap.Const.alter t k f) k' fallback =
if cmp k k' = Ordering.eq then (f (Std.DTreeMap.Const.get? t k)).getD fallback... | null | true |
BoundedOrderHom.dual._proof_3 | Mathlib.Order.Hom.Bounded | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : BoundedOrder α] [inst_2 : Preorder β]
[inst_3 : BoundedOrder β] (f : BoundedOrderHom αᵒᵈ βᵒᵈ), f.toFun ⊥ = ⊥ | null | false |
Membership.mem.step | Init.Data.Range.Basic | ∀ {i : ℕ} {r : Std.Legacy.Range}, i ∈ r → (i - r.start) % r.step = 0 | null | true |
Set.preimage_const_mul_Ioi₀ | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {G₀ : Type u_2} [inst : CommGroupWithZero G₀] [inst_1 : PartialOrder G₀] [PosMulReflectLT G₀] {c : G₀} (a : G₀),
0 < c → (fun x => c * x) ⁻¹' Set.Ioi a = Set.Ioi (a / c) | null | true |
MeasureTheory.Measure.addHaar_smul_of_nonneg | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
0 ≤ r → ∀ (s : Set E), μ (r • s) = ENNReal.ofReal (r ^ Module.finrank ℝ E) * μ s | null | true |
Lean.Parser.Term.doIdbg.formatter | Lean.Parser.Do | Lean.PrettyPrinter.Formatter | null | true |
Lean.Doc.Block._sizeOf_inst | Lean.DocString.Types | (i : Type u) → (b : Type v) → [SizeOf i] → [SizeOf b] → SizeOf (Lean.Doc.Block i b) | null | false |
Int.tdiv_tmod_unique' | Init.Data.Int.DivMod.Lemmas | ∀ {a b r q : ℤ}, a ≤ 0 → b ≠ 0 → (a.tdiv b = q ∧ a.tmod b = r ↔ r + b * q = a ∧ -↑b.natAbs < r ∧ r ≤ 0) | null | true |
Aesop.GoalUnsafe.brecOn_2.eq | Aesop.Tree.Data | ∀ {motive_1 : Aesop.GoalUnsafe → Sort u} {motive_2 : Aesop.MVarClusterUnsafe → Sort u}
{motive_3 : Aesop.RappUnsafe → Sort u} {motive_4 : Aesop.GoalData Aesop.RappUnsafe Aesop.MVarClusterUnsafe → Sort u}
{motive_5 : Aesop.MVarClusterData Aesop.GoalUnsafe Aesop.RappUnsafe → Sort u}
{motive_6 : Aesop.RappData Aesop... | null | true |
PerfectClosure.liftOn.congr_simp | Mathlib.FieldTheory.PerfectClosure | ∀ {K : Type u} [inst : CommRing K] {p : ℕ} [inst_1 : Fact (Nat.Prime p)] [inst_2 : CharP K p] {L : Type u_1}
(x x_1 : PerfectClosure K p),
x = x_1 →
∀ (f f_1 : ℕ × K → L) (e_f : f = f_1) (hf : ∀ (x y : ℕ × K), PerfectClosure.R K p x y → f x = f y),
x.liftOn f hf = x_1.liftOn f_1 ⋯ | null | true |
Lean.Meta.getCtorNumPropFields | Lean.Meta.Tactic.Injection | Lean.ConstructorVal → Lean.MetaM ℕ | null | true |
Std.TreeSet.Equiv.get?_eq | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α},
t₁.Equiv t₂ → t₁.get? k = t₂.get? k | null | true |
RingHom.IsStandardSmooth.smooth | Mathlib.RingTheory.RingHom.LocallyStandardSmooth | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] {f : R →+* S}, f.IsStandardSmooth → f.Smooth | Any standard smooth ring homomorphism is smooth. | true |
Lean.Language.SnapshotTreeTransform.mk | Lean.Language.Basic | Substring.Raw → Lean.Language.SnapshotTreeTransform | null | true |
LocallyConstant.constMonoidHom_apply | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : MulOneClass Y] (y : Y),
LocallyConstant.constMonoidHom y = LocallyConstant.const X y | null | true |
Tilt.instField._proof_23 | Mathlib.RingTheory.Perfection | ∀ (K : Type u_1) [inst : Field K] (v : Valuation K NNReal) (O : Type u_2) [inst_1 : CommRing O] [inst_2 : Algebra O K]
(hv : v.Integers O) (p : ℕ) [inst_3 : Fact (Nat.Prime p)] [hvp : Fact (v ↑p ≠ 1)] (this : Fact ¬IsUnit ↑p),
autoParam (∀ (n : ℕ) (x : Tilt K v O hv p), x ^ (n + 1) = x ^ n * x) Monoid.npow_succ._au... | null | false |
Lean.Meta.withIncSynthPending | Lean.Meta.Basic | {n : Type → Type u_1} → [MonadControlT Lean.MetaM n] → [Monad n] → {α : Type} → n α → n α | null | true |
_private.Mathlib.RingTheory.Perfectoid.BDeRham.0._aux_Mathlib_RingTheory_Perfectoid_BDeRham___unexpand_BDeRhamPlus_1 | Mathlib.RingTheory.Perfectoid.BDeRham | Lean.PrettyPrinter.Unexpander | null | false |
ContinuousMultilinearMap.instAddMonoid._proof_5 | Mathlib.Topology.Algebra.Module.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] [inst_5 : (i : ι) → TopologicalSpace (M₁ i)] [inst_6 : TopologicalSpace M₂]
[inst_7 : Continuous... | null | false |
List.maxIdxOn_lt_length._simp_1 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_1} {α : Type u_2} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []),
(List.maxIdxOn f xs h < xs.length) = True | null | false |
OreLocalization.instCommMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(a : OreLocalization S R), 0 * a = 0 | null | false |
Std.DTreeMap.Internal.Impl.Const.getEntryLT._proof_4 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} [inst : Ord α] [Std.TransOrd α] (k : α) (size : ℕ) (ky : α) (y : β)
(l r : Std.DTreeMap.Internal.Impl α fun x => β),
(∃ a ∈ Std.DTreeMap.Internal.Impl.inner size ky y l r, compare a k = Ordering.lt) →
¬compare k ky = Ordering.gt → ∃ a ∈ l, compare a k = Ordering.lt | null | false |
MeasureTheory.ae_eq_of_forall_setIntegral_eq_of_sigmaFinite | Mathlib.MeasureTheory.Function.AEEqOfIntegral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} [inst : NormedAddCommGroup E]
[inst_1 : NormedSpace ℝ E] [CompleteSpace E] [MeasureTheory.SigmaFinite μ] {f g : α → E},
(∀ (s : Set α), MeasurableSet s → μ s < ⊤ → MeasureTheory.IntegrableOn f s μ) →
(∀ (s : Set α), Measurabl... | null | true |
OrderIso.mapSetOfPredMaximal._proof_4 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t)
(x : ↑{x | Maximal (fun x => x ∈ s) x}), ↑⟨↑(f ⟨↑x, ⋯⟩), ⋯⟩ ∈ t | null | false |
Meromorphic.sub | Mathlib.Analysis.Meromorphic.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {f g : 𝕜 → E}, Meromorphic f → Meromorphic g → Meromorphic (f - g) | null | true |
IsSepClosure.mk._flat_ctor | Mathlib.FieldTheory.IsSepClosed | ∀ {k : Type u} [inst : Field k] {K : Type v} [inst_1 : Field K] [inst_2 : Algebra k K],
IsSepClosed K → Algebra.IsSeparable k K → IsSepClosure k K | null | false |
Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm.swapRows | Mathlib.Tactic.Linarith.Oracle.SimplexAlgorithm.Datatypes | {α : ℕ → ℕ → Type} →
[self : Mathlib.Tactic.Linarith.SimplexAlgorithm.UsableInSimplexAlgorithm α] → {n m : ℕ} → α n m → ℕ → ℕ → α n m | Swaps two rows. | true |
Submodule.comapSubtypeEquivOfLe_symm_apply | Mathlib.Algebra.Module.Submodule.Map | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{p q : Submodule R M} (hpq : p ≤ q) (x : ↥p), (Submodule.comapSubtypeEquivOfLe hpq).symm x = ⟨⟨↑x, ⋯⟩, ⋯⟩ | null | true |
Lean.Syntax.getArg | Init.Prelude | Lean.Syntax → ℕ → Lean.Syntax | Gets the `i`'th argument of the syntax node. This can also be written `stx[i]`.
Returns `missing` if `i` is out of range.
| true |
_private.Lean.Data.Lsp.Extra.0.Lean.Lsp.instFromJsonDependencyBuildMode.fromJson.match_3 | Lean.Data.Lsp.Extra | (motive : Option String → Sort u_1) →
(x : Option String) → ((tag : String) → motive (some tag)) → (Unit → motive none) → motive x | null | false |
CategoryTheory.Functor.weightedLimFlipObjMap_comp_assoc | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] {C : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} C]
{W W' W'' : CategoryTheory.Functor J (Type w)} (g : W ⟶ W') (g' : W' ⟶ W'') (F : CategoryTheory.Functor J C)
[inst_2 : CategoryTheory.Limits.HasWeightedLimit W F] [inst_3 : CategoryTheory.Limits.HasW... | null | true |
Finset.zsmul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Zero α] [inst_2 : Add α] [inst_3 : Neg α],
Finset.zsmul = { smul := fun n s => zsmulRec nsmulRec n s } | null | true |
MeasurableEquiv.map_measurableEquiv_injective | Mathlib.MeasureTheory.Measure.Map | ∀ {α : Type u_1} {β : Type u_2} {x : MeasurableSpace α} [inst : MeasurableSpace β] (e : α ≃ᵐ β),
Function.Injective (MeasureTheory.Measure.map ⇑e) | null | true |
CategoryTheory.Limits.ReflectsColimitsOfShape | Mathlib.CategoryTheory.Limits.Preserves.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(J : Type w) → [CategoryTheory.Category.{w', w} J] → CategoryTheory.Functor C D → Prop | A functor `F : C ⥤ D` reflects colimits of shape `J` if
whenever the image of a cocone over some `K : J ⥤ C` under `F` is a colimit cocone in `D`,
the cocone was already a colimit cocone in `C`.
Note that we do not assume a priori that `D` actually has any colimits.
| true |
CategoryTheory.Limits.PullbackCone.IsLimit.hom_ext | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t) {W : C} {k l : W ⟶ t.pt},
CategoryTheory.CategoryStruct.comp k t.fst = CategoryTheory.CategoryStruct.comp l t.fst →
CategoryTheory.Cate... | null | true |
LieAlgebra.lieCharacterEquivLinearDual_symm_apply | Mathlib.Algebra.Lie.Character | ∀ {R : Type u} {L : Type v} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : IsLieAbelian L]
(ψ : Module.Dual R L), LieAlgebra.lieCharacterEquivLinearDual.symm ψ = { toLinearMap := ψ, map_lie' := ⋯ } | null | true |
IsReduced.mk._flat_ctor | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_5} [inst : Zero R] [inst_1 : Pow R ℕ], (∀ (x : R), IsNilpotent x → x = 0) → IsReduced R | null | false |
CategoryTheory.Limits.FormalCoproduct.evalOpCompInlIsoId._proof_7 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (A : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} A] [inst_2 : CategoryTheory.Limits.HasProducts A]
{X Y : CategoryTheory.Functor Cᵒᵖ A} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(((CategoryTheory.Limits.FormalCoproduct.evalOp C ... | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite.0.SimpleGraph.TripartiteFromTriangles.Graph.in₂₁_iff.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {t : Finset (α × β × γ)} {b : β} {c : γ}
(motive : (∃ a, (a, b, c) ∈ t) → Prop) (x : ∃ a, (a, b, c) ∈ t), (∀ (w : α) (h : (w, b, c) ∈ t), motive ⋯) → motive x | null | false |
Std.Internal.Parsec.instReprParseResult | Std.Internal.Parsec.Basic | {α ι : Type} → [Repr α] → [Repr ι] → Repr (Std.Internal.Parsec.ParseResult α ι) | null | true |
Function.mtr | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, (¬a → ¬b) → b → a | Provide the reverse of modus tollens (`mt`) as dot notation for implications. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.