name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.ExtTreeMap.minKey?_insertIfNew_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
{v : β} {kmi : α}, (t.insertIfNew k v).minKey?.get ⋯ = kmi → (cmp kmi k).isLE = true | null | true |
convexIndependent_iff_notMem_convexHull_diff | Mathlib.Analysis.Convex.Independent | ∀ {𝕜 : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] {p : ι → E},
ConvexIndependent 𝕜 p ↔ ∀ (i : ι) (s : Set ι), p i ∉ (convexHull 𝕜) (p '' (s \ {i})) | **Alias** of `convexIndependent_iff_notMem_convexHull_sdiff`.
---
If a family is convex independent, a point in the family is not in the convex hull of the other
points. See `convexIndependent_set_iff_notMem_convexHull_sdiff` for the `Set` version. | true |
Qq.QuotedDefEq.unsafeIntro | Qq.Typ | ∀ {u : Lean.Level} {α : Q(Sort u)} {lhs rhs : Q(«$α»)}, «$lhs» =Q «$rhs» | For a safer constructor, see `Qq.assertDefEqQ`. | true |
_private.Batteries.Data.Char.AsciiCasing.0.Char.not_isLower_of_isUpper._simp_1_2 | Batteries.Data.Char.AsciiCasing | ∀ {a b : UInt32}, (a ≤ b) = (a.toNat ≤ b.toNat) | null | false |
TopCat.isInitialPEmpty._proof_2 | Mathlib.Topology.Category.TopCat.Limits.Basic | ∀ (X : TopCat) (f : ↧PEmpty.{u_1 + 1} ⟶ X), f = default | null | false |
CategoryTheory.Functor.closedIhom_map_app | Mathlib.CategoryTheory.Monoidal.Closed.FunctorCategory.Groupoid | ∀ {D : Type u} {C : Type u_1} [inst : CategoryTheory.Groupoid D] [inst_1 : CategoryTheory.Category.{v_1, u_1} C]
[inst_2 : CategoryTheory.MonoidalCategory C] [inst_3 : CategoryTheory.MonoidalClosed C]
(F : CategoryTheory.Functor D C) {X Y : CategoryTheory.Functor D C} (g : X ⟶ Y) (X_1 : D),
(F.closedIhom.map g).a... | null | true |
RelSeries.subsingleton_of_length_eq_zero | Mathlib.Order.RelSeries | ∀ {α : Type u_1} {r : SetRel α α} {s : RelSeries r}, s.length = 0 → {x | x ∈ s}.Subsingleton | null | true |
MDifferentiableAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddComm... | Variant of `MDifferentiableAt.prod_map` in which the point in the product is given as `p`
instead of a pair `(x, y)`. | true |
Equiv.nonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : NonUnitalNonAssocSemiring β] (x y : α),
e (e.symm (e.toFun x + e.toFun y)) = e.toFun x + e.toFun y | null | false |
Filter.bot_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {g : Filter α}, ⊥ / g = ⊥ | null | true |
Real.Angle.two_nsmul_eq_pi_iff | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {θ : Real.Angle}, 2 • θ = ↑Real.pi ↔ θ = ↑(Real.pi / 2) ∨ θ = ↑(-Real.pi / 2) | null | true |
BitVec.ofBoolListLE._sunfold | Init.Data.BitVec.Basic | (bs : List Bool) → BitVec bs.length | null | false |
Plausible.Gen.listOf | Plausible.Gen | {α : Type u} → Plausible.Gen α → Plausible.Gen (List α) | Create a `List` of examples using `x`. The size is controlled
by the size parameter of `Gen`. | true |
GroupSeminorm.instIsZeroApplyReal | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : Group E], IsZeroApply (GroupSeminorm E) E ℝ | null | true |
IsTrans.comap | Mathlib.Logic.Relation | ∀ {α : Type u_1} {β : Type u_2} {r : β → β → Prop} [IsTrans β r] (f : α → β), IsTrans α (Function.onFun r f) | null | true |
Order.succ_eq_succ_iff._simp_2 | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : SuccOrder α] {a b : α} [NoMaxOrder α],
(Order.succ a = Order.succ b) = (a = b) | null | false |
RatFunc.algEquivOfTranscendental._proof_11 | Mathlib.FieldTheory.RatFunc.AsPolynomial | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] (f : L),
IsScalarTower K ↥K[f] ↥K⟮f⟯ | null | false |
ge_imp_gt_of_lt | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b c : α}, a < b → a ≥ c → b > c | null | true |
MeasureTheory.meas_le_ae_eq_meas_lt | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] (μ : MeasureTheory.Measure α) {R : Type u_3} [inst_1 : LinearOrder R]
[inst_2 : MeasurableSpace R] (ν : MeasureTheory.Measure R) [MeasureTheory.NullSingletonClass ν] (g : α → R),
(fun t => μ {a | t ≤ g a}) =ᵐ[ν] fun t => μ {a | t < g a} | null | true |
AddConstEquiv.instEquivLike._proof_2 | Mathlib.Algebra.AddConstMap.Equiv | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] {a : G} {b : H} (f : AddConstEquiv G H a b),
Function.RightInverse f.invFun f.toFun | null | false |
BitVec.getLsbD_eq_decide_getElem | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec w) (i : ℕ), x.getLsbD i = decide (∃ (h : i < w), x[i] = true) | null | true |
PNat.gcdB' | Mathlib.Data.PNat.Xgcd | ℕ+ → ℕ+ → ℕ+ | Final value of `b / d` | true |
retractionKerCotangentToTensorEquivSection.match_3 | Mathlib.RingTheory.Smooth.Kaehler | {R : Type u_3} →
{P : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing P] →
[inst_2 : CommRing S] →
[inst_3 : Algebra R P] →
[inst_4 : Algebra P S] →
let P' := P ⧸ RingHom.ker (algebraMap P S) ^ 2;
(motive : { l... | null | false |
Int8.ofIntLE_bitVecToInt._proof_1 | Init.Data.SInt.Lemmas | ∀ (n : BitVec 8), Int8.minValue.toInt ≤ n.toInt | null | false |
MeasureTheory.lintegral_comp_eq_lintegral_meas_lt_mul | Mathlib.MeasureTheory.Integral.Layercake | ∀ {α : Type u_1} [inst : MeasurableSpace α] {f : α → ℝ} {g : ℝ → ℝ} (μ : MeasureTheory.Measure α),
0 ≤ᵐ[μ] f →
AEMeasurable f μ →
(∀ t > 0, IntervalIntegrable g MeasureTheory.volume 0 t) →
(∀ᵐ (t : ℝ) ∂MeasureTheory.volume.restrict (Set.Ioi 0), 0 ≤ g t) →
∫⁻ (ω : α), ENNReal.ofReal (∫ (t :... | The layer cake formula / Cavalieri's principle / tail probability formula:
Let `f` be a non-negative measurable function on a measure space. Let `G` be an
increasing absolutely continuous function on the positive real line, vanishing at the origin,
with derivative `G' = g`. Then the integral of the composition `G ∘ f`... | true |
CategoryTheory.Monad.forget_map | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] (T : CategoryTheory.Monad C) {X Y : T.Algebra} (f : X ⟶ Y),
T.forget.map f = f.f | null | true |
LinearMap.range_domRestrict_eq_range_iff | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_4} {M₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : AddCommGroup M₂] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
[inst_6 : RingHomSurjective τ₁₂] {f : M →ₛₗ[τ₁₂] M₂} {S : Submodule R M},
(f.domRestrict S)... | null | true |
Lean.Parser.Command.grindPattern.parenthesizer | Lean.Meta.Tactic.Grind.Parser | Lean.PrettyPrinter.Parenthesizer | null | true |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_1 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u} {s t : Set α}, Disjoint s t = (s ∩ t = ∅) | null | false |
_private.Init.Data.List.Sort.Basic.0.List.merge._unary._proof_2 | Init.Data.List.Sort.Basic | ∀ {α : Type u_1} (x : α) (xs : List α) (y : α) (ys : List α),
(invImage (fun x => PSigma.casesOn x fun xs ys => (xs, ys)) Prod.instWellFoundedRelation).1 ⟨xs, y :: ys⟩
⟨x :: xs, y :: ys⟩ | null | false |
RelIso.casesOn | Mathlib.Order.RelIso.Basic | {α : Type u_5} →
{β : Type u_6} →
{r : α → α → Prop} →
{s : β → β → Prop} →
{motive : r ≃r s → Sort u} →
(t : r ≃r s) →
((toEquiv : α ≃ β) →
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b) →
motive { toEquiv := toEquiv, map_rel_... | null | false |
TensorProduct.AlgebraTensorModule.rightComm._proof_8 | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ (R : Type u_1) (S : Type u_2) (M : Type u_3) (P : Type u_4) (Q : Type u_5) [inst : CommSemiring R]
[inst_1 : AddCommMonoid M] [inst_2 : Module R M] [inst_3 : AddCommMonoid P] [inst_4 : AddCommMonoid Q]
[inst_5 : Module R Q] [inst_6 : CommSemiring S] [inst_7 : Module S M] [inst_8 : Module S P]
[inst_9 : SMulComm... | null | false |
Lean.Elab.WF.GuessLex.withUserNames | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} → Array Lean.Expr → Array Lean.Name → Lean.MetaM α → Lean.MetaM α | Sets the user names for the given free variables in `xs`. | true |
Subgroup.coe_square | Mathlib.Algebra.Group.Subgroup.Even | ∀ {G : Type u_1} [inst : CommGroup G], ↑(Subgroup.square G) = {s | IsSquare s} | null | true |
Aesop.UnfoldRule.mk.injEq | Aesop.Rule | ∀ (decl : Lean.Name) (unfoldThm? : Option Lean.Name) (decl_1 : Lean.Name) (unfoldThm?_1 : Option Lean.Name),
({ decl := decl, unfoldThm? := unfoldThm? } = { decl := decl_1, unfoldThm? := unfoldThm?_1 }) =
(decl = decl_1 ∧ unfoldThm? = unfoldThm?_1) | null | true |
String.Slice.Pattern.Model.IsValidSearchFrom.matched_of_eq | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice}
{startPos startPos' endPos : s.Pos} {l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom pat endPos l →
String.Slice.Pattern.Model.IsLongestMatchAt pat startPos' endPos →
... | null | true |
EReal.mul_div_left_comm | Mathlib.Data.EReal.Inv | ∀ (a b c : EReal), a * (b / c) = b * (a / c) | null | true |
LieHom.mk.congr_simp | Mathlib.Algebra.Lie.Basic | ∀ {R : Type u_1} {L : Type u_2} {L' : Type u_3} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
[inst_3 : LieRing L'] [inst_4 : LieAlgebra R L'] (toLinearMap toLinearMap_1 : L →ₗ[R] L')
(e_toLinearMap : toLinearMap = toLinearMap_1)
(map_lie' : ∀ {x y : L}, toLinearMap.toFun ⁅x, y⁆ = ⁅toLinearMa... | null | true |
Std.DHashMap.Internal.Raw₀.erase_equiv_congr | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] (m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β)
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → (↑m₁).Equiv ↑m₂ → ∀ {k : α}, (↑(m₁.erase k)).Equiv ↑(m₂.erase k) | null | true |
Lean.CasesInfo.mk.noConfusion | Lean.Meta.CasesInfo | {P : Sort u} →
{declName indName : Lean.Name} →
{arity discrPos motivePos : ℕ} →
{altsRange : Std.Rco ℕ} →
{altNumParams : Array Lean.CasesAltInfo} →
{declName' indName' : Lean.Name} →
{arity' discrPos' motivePos' : ℕ} →
{altsRange' : Std.Rco ℕ} →
... | null | false |
ArchimedeanClass.instFieldFiniteResidueField._proof_31 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | null | false |
Nat.mem_primeFactorsList_mul | Mathlib.Data.Nat.Factors | ∀ {a b : ℕ}, a ≠ 0 → b ≠ 0 → ∀ {p : ℕ}, p ∈ (a * b).primeFactorsList ↔ p ∈ a.primeFactorsList ∨ p ∈ b.primeFactorsList | null | true |
InnerProductSpace.Core.toNormedAddCommGroupOfTopology | Mathlib.Analysis.InnerProductSpace.Defs | {𝕜 : Type u_1} →
{F : Type u_3} →
[inst : RCLike 𝕜] →
[inst_1 : AddCommGroup F] →
[inst_2 : Module 𝕜 F] →
[cd : InnerProductSpace.Core 𝕜 F] →
[tF : TopologicalSpace F] →
[IsTopologicalAddGroup F] →
[ContinuousConstSMul 𝕜 F] →
... | Normed space structure constructed from an `InnerProductSpace.Core` structure, adjusting the
topology to make sure it is defeq to an already existing topology. | true |
Set.partialHomeomorphSubtypeCoe_coe | Mathlib.Topology.PartialHomeomorph.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] (s : Set X) (hs : Nonempty ↑s),
↑(s.partialHomeomorphSubtypeCoe hs) = Subtype.val | null | true |
finsum_sum_comm | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (s : Finset β) (f : α → β → M),
(∀ b ∈ s, Function.HasFiniteSupport fun a => f a b) → ∑ᶠ (a : α), ∑ b ∈ s, f a b = ∑ b ∈ s, ∑ᶠ (a : α), f a b | null | true |
AddCommGrpCat.Colimits.Quot.ι_desc | Mathlib.Algebra.Category.Grp.Colimits | ∀ {J : Type u} [inst : CategoryTheory.Category.{v, u} J] (F : CategoryTheory.Functor J AddCommGrpCat)
(c : CategoryTheory.Limits.Cocone F) [inst_1 : DecidableEq J] (j : J) (x : ↑(F.obj j)),
(AddCommGrpCat.Colimits.Quot.desc F c) ((AddCommGrpCat.Colimits.Quot.ι F j) x) =
(CategoryTheory.ConcreteCategory.hom (c.ι... | null | true |
CategoryTheory.ShortComplex.cyclesFunctorIso._proof_3 | Mathlib.Algebra.Homology.ShortComplex.PreservesHomology | ∀ {C : Type u_4} {D : Type u_2} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms D] (F : CategoryTheory.Functor C D)
[inst_4 : F.PreservesZeroMorphisms] [CategoryTheory... | null | false |
Lean.Grind.OrderedAdd.zsmul_le_zsmul | Init.Grind.Ordered.Module | ∀ {M : Type u} [inst : LE M] [inst_1 : Std.IsPreorder M] [inst_2 : Lean.Grind.IntModule M] [Lean.Grind.OrderedAdd M]
{a b : M} {k : ℤ}, 0 ≤ k → a ≤ b → k • a ≤ k • b | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_union_of_contains_eq_false_left._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 |
Array.mem_flatten_of_mem | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xss : Array (Array α)} {xs : Array α} {a : α}, xs ∈ xss → a ∈ xs → a ∈ xss.flatten | null | true |
CategoryTheory.ShortComplex.HomologyData.ofIsIsoLeftRightHomologyComparison' | Mathlib.Algebra.Homology.ShortComplex.Homology | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{S : CategoryTheory.ShortComplex C} →
(h₁ : S.LeftHomologyData) →
(h₂ : S.RightHomologyData) →
[CategoryTheory.IsIso (CategoryTheory.ShortComplex.leftRightHomologyCo... | This is the homology data for a short complex `S` that is obtained
from a left homology data `h₁` and a right homology data `h₂` when the comparison
morphism `leftRightHomologyComparison' h₁ h₂ : h₁.H ⟶ h₂.H` is an isomorphism. | true |
Representation.linearizeOfMulActionIso.eq_1 | Mathlib.RepresentationTheory.Homological.Resolution | ∀ (k : Type u) (G : Type v) [inst : Monoid G] [inst_1 : Semiring k] (H : Type w) [inst_2 : MulAction G H],
Representation.linearizeOfMulActionIso k G H =
Representation.Equiv.mk (LinearEquiv.refl k (MonoidAlgebra k (Action.ofMulAction G H).V)) ⋯ | null | true |
Aesop.Nanos.mk | Aesop.Nanos | ℕ → Aesop.Nanos | null | true |
AlgebraicGeometry.functionField_isFractionRing_of_isAffineOpen | Mathlib.AlgebraicGeometry.FunctionField | ∀ (X : AlgebraicGeometry.Scheme) [inst : AlgebraicGeometry.IsIntegral X] (U : X.Opens),
AlgebraicGeometry.IsAffineOpen U →
∀ [inst_1 : Nonempty ↥↑U], IsFractionRing ↑(X.presheaf.obj (Opposite.op U)) ↑X.functionField | null | true |
CategoryTheory.Functor.final_const_terminal | Mathlib.CategoryTheory.Filtered.Final | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[CategoryTheory.IsFiltered C] [inst_3 : CategoryTheory.Limits.HasTerminal D],
((CategoryTheory.Functor.const C).obj (⊤_ D)).Final | The inclusion of the terminal object is final. | true |
CategoryTheory.Sieve.sSup_apply | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C} {Ss : Set (CategoryTheory.Sieve X)} {Y : C}
(f : Y ⟶ X), (sSup Ss).arrows f ↔ ∃ S, ∃ (_ : S ∈ Ss), S.arrows f | null | true |
AlgebraicGeometry.LocallyOfFinitePresentation.SpecMap_iff | Mathlib.AlgebraicGeometry.Morphisms.FinitePresentation | ∀ {R S : CommRingCat} (f : R ⟶ S),
AlgebraicGeometry.LocallyOfFinitePresentation (AlgebraicGeometry.Spec.map f) ↔
(CommRingCat.Hom.hom f).FinitePresentation | null | true |
Int.lt_of_add_lt_add_left | Init.Data.Int.Order | ∀ {a b c : ℤ}, a + b < a + c → b < c | null | true |
_private.Mathlib.RingTheory.Binomial.0.Ring.smeval_ascPochhammer_self_neg.match_1_1 | Mathlib.RingTheory.Binomial | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
MeasureTheory.VectorMeasure.variation_apply_eq_zero | Mathlib.MeasureTheory.VectorMeasure.Variation.Basic | ∀ {X : Type u_1} {V : Type u_2} {mX : MeasurableSpace X} [inst : TopologicalSpace V] [inst_1 : ENormedAddCommMonoid V]
[inst_2 : T2Space V] {μ : MeasureTheory.VectorMeasure X V} {s : Set X},
MeasurableSet s → (μ.variation s = 0 ↔ ∀ t ⊆ s, MeasurableSet t → μ t = 0) | null | true |
Algebra.adjoin_singleton_natCast | Mathlib.Algebra.Algebra.Subalgebra.Lattice | ∀ (R : Type uR) (A : Type uA) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (n : ℕ), R[↑n] = ⊥ | null | true |
WithTop.LinearOrderedAddCommGroup.instLinearOrderedAddCommGroupWithTopOfIsOrderedAddMonoid.match_1 | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {G : Type u_1} [inst : AddCommGroup G] [inst_1 : LinearOrder G] [inst_2 : IsOrderedAddMonoid G]
(motive : (x : WithTop G) → x ≠ ⊤ → Prop) (x : WithTop G) (x_1 : x ≠ ⊤),
(∀ (a : G) (x : ↑a ≠ ⊤), motive (some a) x) → motive x x_1 | null | false |
ProjectiveSpectrum.zeroLocus_iSup_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] {γ : Sort u_3} (I : γ → HomogeneousIdeal 𝒜),
ProjectiveSpectrum.zeroLocus 𝒜 ↑(⨆ i, I i) = ⋂ i, ProjectiveSpectrum.zeroLocus 𝒜 ↑(I i) | null | true |
CategoryTheory.ComposableArrows.fourδ₁Toδ₀_app_one | Mathlib.CategoryTheory.ComposableArrows.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {i₀ i₁ i₂ i₃ i₄ : C} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂)
(f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₁₂ : i₀ ⟶ i₂) (h₁₂ : CategoryTheory.CategoryStruct.comp f₁ f₂ = f₁₂),
(CategoryTheory.ComposableArrows.fourδ₁Toδ₀ f₁ f₂ f₃ f₄ f₁₂ h₁₂).app 1 =
CategoryTheory.Category... | null | true |
_private.Batteries.Data.List.Interleave.0.List.interleave_flatten_flatten_of_length_eq_length._proof_1_4 | Batteries.Data.List.Interleave | ∀ {α : Type u_1} (head head_1 : List α) (tail : List (List α)) (l head_2 : List α) (tail_1 : List (List α)),
(head :: head_1 :: tail).length = (l :: head_2 :: tail_1).length →
∀ (i : ℕ), i + 2 ≤ (head :: head_1 :: tail).length → i < (l :: head_2 :: tail_1).length | null | false |
SimpleGraph.replaceVertex.eq_1 | Mathlib.Combinatorics.SimpleGraph.Operations | ∀ {V : Type u_1} (G : SimpleGraph V) (s t : V) [inst : DecidableEq V],
G.replaceVertex s t =
{ Adj := fun v w => if v = t then if w = t then False else G.Adj s w else if w = t then G.Adj v s else G.Adj v w,
symm := ⋯, loopless := ⋯ } | null | true |
Valuation.IsRankOneDiscrete.generator_eq_exp_neg_one_of_mem_range._proof_1 | Mathlib.RingTheory.Valuation.Discrete.Basic | WithZero.exp (-1) ≠ 0 | null | false |
Vector.ne_and_not_mem_of_not_mem_push | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {a y : α} {xs : Vector α n}, a ∉ xs.push y → a ≠ y ∧ a ∉ xs | null | true |
RBTree.RBNode.node.injEq | Batteries.Recycling.RBTree.Basic | ∀ {α : Type u} (c : RBTree.RBColor) (l : RBTree.RBNode α) (v : α) (r : RBTree.RBNode α) (c_1 : RBTree.RBColor)
(l_1 : RBTree.RBNode α) (v_1 : α) (r_1 : RBTree.RBNode α),
(RBTree.RBNode.node c l v r = RBTree.RBNode.node c_1 l_1 v_1 r_1) = (c = c_1 ∧ l = l_1 ∧ v = v_1 ∧ r = r_1) | null | true |
Lean.Elab.Term.Do.instInhabitedCode | Lean.Elab.Do.Legacy | Inhabited Lean.Elab.Term.Do.Code | null | true |
Std.DHashMap.Internal.Raw.Const.get_eq._proof_1 | Std.Data.DHashMap.Internal.Raw | ∀ {α : Type u_1} {β : Type u_2} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α fun x => β} {a : α}
{h : a ∈ m}, 0 < m.buckets.size | null | false |
MonoidHom.injective_codRestrict._simp_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : SubmonoidClass S N] (f : M →* N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f | null | false |
List.mapFinIdx.go | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(as : List α) →
((i : ℕ) → α → i < as.length → β) → (bs : List α) → (acc : Array β) → bs.length + acc.size = as.length → List β | Auxiliary for `mapFinIdx`:
`mapFinIdx.go [a₀, a₁, ...] acc = acc.toList ++ [f 0 a₀ ⋯, f 1 a₁ ⋯, ...]` | true |
SSet.Subcomplex.Pairing.RankFunction.Cell.mapToSucc.eq_1 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.RelativeCellComplex | ∀ {X : SSet} {A : X.Subcomplex} {P : A.Pairing} {ι : Type v} [inst : LinearOrder ι] {f : P.RankFunction ι}
[inst_1 : P.IsProper] {j : ι} [inst_2 : SuccOrder ι] [inst_3 : NoMaxOrder ι] (c : f.Cell j),
c.mapToSucc = SSet.Subcomplex.lift c.map ⋯ | null | true |
MulDistribMulActionHom.map_mul | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_1} [inst : Monoid M] {N : Type u_2} [inst_1 : Monoid N] {φ : M →* N} {A : Type u_4} [inst_2 : Monoid A]
[inst_3 : MulDistribMulAction M A] {B : Type u_5} [inst_4 : Monoid B] [inst_5 : MulDistribMulAction N B]
(f : A →ₑ*[φ] B) (x y : A), f (x * y) = f x * f y | null | true |
Quiver.Hom.unop_ext | Mathlib.Combinatorics.Quiver.Basic | ∀ {V : Type u_1} [inst : Quiver V] {X Y : Vᵒᵖ} {f g : X ⟶ Y}, f.unop = g.unop → f = g | To show that two Homs from the opposite category agree, it suffices to show they agree
in the original category. | true |
_private.Aesop.Tree.Data.0.Aesop.GoalOrigin.originalGoalId?._sparseCasesOn_1 | Aesop.Tree.Data | {motive : Aesop.GoalOrigin → Sort u} →
(t : Aesop.GoalOrigin) →
((«from» rep : Aesop.GoalId) → motive (Aesop.GoalOrigin.copied «from» rep)) →
(Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
OrderIso.isCoatom_iff | Mathlib.Order.Atoms | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : PartialOrder β] [inst_2 : OrderTop α]
[inst_3 : OrderTop β] (f : α ≃o β) (a : α), IsCoatom (f a) ↔ IsCoatom a | null | true |
Std.DHashMap.Internal.Raw₀.Const.getD_diff_of_contains_right | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α fun x => β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF →
(↑m₂).WF →
∀ {k : α} {fallback : β},
m₂.contains k = true → Std.DHashMap.Internal.Raw₀.Const.getD (m₁.diff m₂) k fallback = fallback | null | true |
MeasureTheory.addContent_eq_add_disjointOfDiffUnion_of_subset | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} {C : Set (Set α)} {s : Set α} {I : Finset (Set α)} {G : Type u_2} [inst : AddCommMonoid G]
{m : MeasureTheory.AddContent G C} (hC : MeasureTheory.IsSetSemiring C) (hs : s ∈ C) (hI : ↑I ⊆ C),
(∀ t ∈ I, t ⊆ s) → (↑I).PairwiseDisjoint id → m s = ∑ i ∈ I, m i + ∑ i ∈ hC.disjointOfDiffUnion hs hI, m i | null | true |
_private.Mathlib.ModelTheory.Complexity.0.FirstOrder.Language.BoundedFormula.IsAtomic.realize_comp_of_injective._simp_1_4 | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {α : Type u'} {l : ℕ} {v : α → M} {xs : Fin l → M}
{k : ℕ} {R : L.Relations k} {ts : Fin k → L.Term (α ⊕ Fin l)},
(R.boundedFormula ts).Realize v xs =
FirstOrder.Language.Structure.RelMap R fun i => FirstOrder.Language.Term.realize (Sum.elim v xs) ... | null | false |
CategoryTheory.Limits.ChosenEndsOfShape.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Chosen.End | {J : Type u_3} →
[inst : CategoryTheory.Category.{v_3, u_3} J] →
{C : Type u_4} →
[inst_1 : CategoryTheory.Category.{v_4, u_4} C] →
(wedge : (F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Functor J C)) → CategoryTheory.Limits.Wedge F) →
((F : CategoryTheory.Functor Jᵒᵖ (CategoryTheory.Fun... | null | false |
Std.DTreeMap.Internal.RcoSliceData.mk.injEq | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rco α)
(treeMap_1 : Std.DTreeMap.Internal.Impl α β) (range_1 : Std.Rco α),
({ treeMap := treeMap, range := range } = { treeMap := treeMap_1, range := range_1 }) =
(treeMap = treeMap_1 ∧ range = range_1) | null | true |
Lean.instQuoteCharCharLitKind | Init.Meta.Defs | Lean.Quote Char Lean.charLitKind | null | true |
Function.FromTypes.uncurry_two_eq_uncurry | Mathlib.Data.Fin.Tuple.Curry | ∀ (p : Fin 2 → Type u) (τ : Type u) (f : Function.FromTypes p τ), f.uncurry = Function.uncurry f ∘ ⇑(piFinTwoEquiv p) | null | true |
DirectSum.lieAlgebraComponent._proof_1 | Mathlib.Algebra.Lie.DirectSum | ∀ (R : Type u_3) (ι : Type u_2) [inst : CommRing R] (L : ι → Type u_1) [inst_1 : (i : ι) → LieRing (L i)]
[inst_2 : (i : ι) → LieAlgebra R (L i)] (j : ι) {x y : DirectSum ι fun i => L i},
(DirectSum.component R ι L j) ⁅x, y⁆ = ⁅(DirectSum.component R ι L j) x, (DirectSum.component R ι L j) y⁆ | null | false |
CategoryTheory.PreOneHypercover.instUniqueLMulticospanShapeSigmaOfIsColimit._aux_1 | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} C] →
{S : C} →
(E : CategoryTheory.PreOneHypercover S) →
{c : CategoryTheory.Limits.Cofan E.X} →
(hc : CategoryTheory.Limits.IsColimit c) →
{d : CategoryTheory.Limits.Cofan E.Y'} →
(hd : CategoryTheory.Li... | null | false |
Lean.ElabInline.custom | Lean.DocString.Extension | Dynamic → Lean.ElabInline | A custom inline element. The type of the value in the `Dynamic` determines how it is interpreted
and rendered.
| true |
_private.Init.Data.Format.Basic.0.Std.Format.SpaceResult.mk | Init.Data.Format.Basic | Bool → Bool → ℕ → Std.Format.SpaceResult✝ | null | true |
Set.ncard_sdiff' | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s ⊆ t → autoParam t.Finite Set.ncard_sdiff'._auto_1 → (t \ s).ncard = t.ncard - s.ncard | This is the same as `ncard_sdiff` but we require `t` to be finite instead. | true |
TypeVec.lastFun_appendFun | Mathlib.Data.TypeVec | ∀ {n : ℕ} {α : TypeVec.{u_1} n} {α' : TypeVec.{u_2} n} {β : Type u_1} {β' : Type u_2} (f : α.Arrow α') (g : β → β'),
TypeVec.lastFun (f ::: g) = g | null | true |
_private.Mathlib.Algebra.Polynomial.FieldDivision.0.Polynomial.remainder_lt_aux | Mathlib.Algebra.Polynomial.FieldDivision | ∀ {R : Type u} [inst : Field R] {q : Polynomial R} (p : Polynomial R), q ≠ 0 → (p.mod q).degree < q.degree | null | true |
UInt16.xor_eq_zero_iff._simp_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt16}, (a ^^^ b = 0) = (a = b) | null | false |
Inclusion.IExpr.mk.inj | Mathlib.Tactic.Inclusion.Core.Types | ∀ {iType : Inclusion.IType} {expr : Lean.Expr} {iType_1 : Inclusion.IType} {expr_1 : Lean.Expr},
{ iType := iType, expr := expr } = { iType := iType_1, expr := expr_1 } → iType = iType_1 ∧ expr = expr_1 | null | true |
_private.Mathlib.RingTheory.TensorProduct.DirectLimitFG.0.TensorProduct.Algebra.eq_of_fg_of_subtype_eq._simp_1_11 | Mathlib.RingTheory.TensorProduct.DirectLimitFG | ∀ {α : Type u} {s t : Set α}, (t ⊆ s ∪ t) = True | null | false |
CategoryTheory.OverPresheafAux.OverArrows.yonedaArrow_val | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : CategoryTheory.Functor Cᵒᵖ (Type v)} {Y : C}
{η : CategoryTheory.yoneda.obj Y ⟶ A} {X : C} {s : CategoryTheory.yoneda.obj X ⟶ A} {f : X ⟶ Y}
(hf : CategoryTheory.CategoryStruct.comp (CategoryTheory.yoneda.map f) η = s),
(CategoryTheory.OverPresheafAux.... | null | true |
MvPowerSeries.IsRestricted.sum | Mathlib.RingTheory.MvPowerSeries.Restricted | ∀ {R : Type u_1} [inst : NormedRing R] {σ : Type u_2} {c : σ → ℝ} {ι : Type u_3} {s : Finset ι}
{f : ι → MvPowerSeries σ R},
(∀ i ∈ s, MvPowerSeries.IsRestricted c (f i)) → MvPowerSeries.IsRestricted c (∑ i ∈ s, f i) | null | true |
SNum._aux_Mathlib_Data_Num_Bitwise___unexpand_SNum_bit_1 | Mathlib.Data.Num.Bitwise | Lean.PrettyPrinter.Unexpander | null | false |
IO.instLTTaskState | Init.System.IO | LT IO.TaskState | null | true |
Lean.Lsp.SnippetString.noConfusion | Lean.Data.Lsp.Basic | {P : Sort u} → {t t' : Lean.Lsp.SnippetString} → t = t' → Lean.Lsp.SnippetString.noConfusionType P t t' | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.