name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.minKey_modify._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
CategoryTheory.BinaryCofan.isVanKampen_iff | Mathlib.CategoryTheory.Limits.VanKampen | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (c : CategoryTheory.Limits.BinaryCofan X Y),
CategoryTheory.IsVanKampenColimit c ↔
∀ {X' Y' : C} (c' : CategoryTheory.Limits.BinaryCofan X' Y') (αX : X' ⟶ X) (αY : Y' ⟶ Y) (f : c'.pt ⟶ c.pt),
CategoryTheory.CategoryStruct.comp αX c.inl = Cat... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass.0.PeriodPair.summable_weierstrassPExceptSummand._simp_1_7 | Mathlib.Analysis.SpecialFunctions.Elliptic.Weierstrass | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Submodule.projectionL_add_projectionL_eq_id | Mathlib.Topology.Algebra.Module.Complement | ∀ {R : Type u_1} [inst : Ring R] {M : Type u_2} [inst_1 : TopologicalSpace M] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] {p q : Submodule R M} [inst_4 : IsTopologicalAddGroup M] (h : Submodule.IsTopCompl p q),
p.projectionL q h + q.projectionL p ⋯ = ContinuousLinearMap.id R M | null | true |
_private.Batteries.Data.String.Lemmas.0.String.utf8GetAux_of_valid._simp_1_3 | Batteries.Data.String.Lemmas | ∀ {x y : String.Pos.Raw}, (x = y) = (x.byteIdx = y.byteIdx) | null | false |
Subalgebra.ofRestrictScalars._proof_1 | Mathlib.Algebra.Algebra.Subalgebra.Tower | ∀ (R : Type u_1) {S : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : CommSemiring S] [inst_2 : Semiring A]
[inst_3 : Algebra R S] [inst_4 : Algebra S A] [inst_5 : Algebra R A] [inst_6 : IsScalarTower R S A]
(U : Subalgebra S A), IsScalarTower R S ↥U | null | false |
Std.Tactic.BVDecide.BVExpr.PackedBitVec.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} {bv : BitVec w} {w_1 : ℕ} {bv_1 : BitVec w_1},
{ w := w, bv := bv } = { w := w_1, bv := bv_1 } → w = w_1 ∧ bv ≍ bv_1 | null | true |
Std.ExtTreeMap.getD_eq_fallback_of_contains_eq_false | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α}
{fallback : β}, t.contains a = false → t.getD a fallback = fallback | null | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.IsImage.ofArrowIso._simp_2 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (α : Y ⟶ X) [inst_1 : CategoryTheory.IsIso α]
{f : Z ⟶ X} {g : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp f (CategoryTheory.inv α) = g) = (f = CategoryTheory.CategoryStruct.comp g α) | null | false |
Polynomial.supNorm_eq_zero_iff | Mathlib.Analysis.Polynomial.Norm | ∀ {A : Type u_1} [inst : NormedRing A] (p : Polynomial A), p.supNorm = 0 ↔ p = 0 | null | true |
UpperSet.instAddAction._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : Preorder α], Function.Injective SetLike.coe | null | false |
CategoryTheory.GrothendieckTopology.toPlus_comp_plusCompIso_inv | Mathlib.CategoryTheory.Sites.CompatiblePlus | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.GrothendieckTopology C) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{v_2, u_2} E]
(F : CategoryTheory.Functor D E)
[inst_3 :
∀ (J : CategoryTheory.Limits.Multicospan... | null | true |
Int.tdiv.eq_4 | Init.Data.Int.DivMod.Lemmas | ∀ (m n : ℕ), (Int.negSucc m).tdiv (Int.negSucc n) = Int.ofNat (m.succ / n.succ) | null | true |
SimpleGraph.cliqueFree_of_card_lt | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} {n : ℕ} [inst : Fintype α], Fintype.card α < n → G.CliqueFree n | See `SimpleGraph.cliqueFree_of_chromaticNumber_lt` for a tighter bound. | true |
closedBall_rpow_sub_one_eq_empty_aux | Mathlib.Analysis.SpecialFunctions.JapaneseBracket | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] {r t : ℝ}, 0 < r → 1 < t → Metric.closedBall 0 (t ^ (-r⁻¹) - 1) = ∅ | null | true |
MvPowerSeries.subst_X | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S},
MvPowerSeries.HasSubst a → ∀ (s : σ), MvPowerSeries.subst a (MvPowerSeries.X s) = a s | null | true |
Vector.mapFinIdx._proof_1 | Init.Data.Vector.Basic | ∀ {α : Type u_1} {n : ℕ} (xs : Vector α n), ∀ i < xs.toArray.size, i < n | null | false |
_private.Mathlib.ModelTheory.Arithmetic.Presburger.Definability.0.FirstOrder.Language.presburger.mul_not_definable._proof_1_6 | Mathlib.ModelTheory.Arithmetic.Presburger.Definability | ∀ (k p : ℕ), p > 0 → ∀ (x : ℕ), x * x = max k p * max k p + p → x * x ≤ max k p * max k p → False | null | false |
_private.Mathlib.Order.Filter.ENNReal.0.NNReal.toReal_liminf._simp_1_8 | Mathlib.Order.Filter.ENNReal | ∀ {p : NNReal → Prop}, (∀ (x : NNReal), p x) = ∀ (x : ℝ) (hx : 0 ≤ x), p (NNReal.mk x hx) | null | false |
PresheafOfModules.ModuleColimit.homEquiv._proof_7 | Mathlib.Algebra.Category.ModuleCat.Presheaf.ColimitFunctor | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] [inst_1 : CategoryTheory.LocallySmall.{u_1, u_2, u_3} C]
[inst_2 : CategoryTheory.IsCofiltered C] [inst_3 : CategoryTheory.InitiallySmall C]
{R : CategoryTheory.Functor Cᵒᵖ RingCat} {cR : CategoryTheory.Limits.Cocone R}
(hcR : CategoryTheory.Limits.Is... | null | false |
have_body_congr_dep' | Init.SimpLemmas | ∀ {α : Sort u} {β : α → Sort v} (a : α) {f f' : (x : α) → β x}, (∀ (x : α), f x = f' x) → f a = f' a | null | true |
commGrpTypeEquivalenceCommGrp._proof_2 | Mathlib.CategoryTheory.Monoidal.Internal.Types.CommGrp_ | ∀ (X : CategoryTheory.CommGrp (Type u_1)),
CategoryTheory.CategoryStruct.comp
(CommGrpTypeEquivalenceCommGrp.functor.map
((CategoryTheory.Iso.refl (CategoryTheory.Functor.id (CategoryTheory.CommGrp (Type u_1)))).hom.app X))
((CategoryTheory.NatIso.ofComponents
(fun A =>
... | null | false |
CompactlyGeneratedSpace.isClosed | Mathlib.Topology.Compactness.CompactlyGeneratedSpace | ∀ {X : Type u} [inst : TopologicalSpace X] [CompactlyGeneratedSpace X] {s : Set X},
(∀ ⦃K : Set X⦄, IsCompact K → IsClosed (s ∩ K)) → IsClosed s | In a compactly generated space `X`, a set `s` is closed when `s ∩ K` is
closed for every compact set `K`. | true |
Std.HashMap.mem_keys | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [LawfulBEq α] {k : α},
k ∈ m.keys ↔ k ∈ m | null | true |
isInducing_stoneCechUnit | Mathlib.Topology.Separation.CompletelyRegular | ∀ {X : Type u} [inst : TopologicalSpace X] [CompletelyRegularSpace X], Topology.IsInducing stoneCechUnit | null | true |
Array.eraseIdx_insertIdx_self | Init.Data.Array.InsertIdx | ∀ {α : Type u} {a : α} {i : ℕ} {xs : Array α} (h : i ≤ xs.size), (xs.insertIdx i a h).eraseIdx i ⋯ = xs | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd.0.SSet.prodStdSimplex.pairingCore.IsIndex.δ._simp_7 | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
_private.Mathlib.Probability.Process.HittingTime.0.MeasureTheory.Adapted.isStoppingTime_hittingBtwn_isStoppingTime._simp_1_13 | Mathlib.Probability.Process.HittingTime | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | null | false |
Lean.Doc.State._sizeOf_inst | Lean.Elab.DocString | SizeOf Lean.Doc.State | null | false |
OrderDual.instDivisionRing | Mathlib.Algebra.Field.Basic | {K : Type u_1} → [DivisionRing K] → DivisionRing Kᵒᵈ | null | true |
Std.DTreeMap.Internal.Impl.Const.get?_insertManyIfNewUnit_list | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α fun x => Unit} [Std.TransOrd α] [inst : BEq α]
[Std.LawfulBEqOrd α] (h : t.WF) {l : List α} {k : α},
Std.DTreeMap.Internal.Impl.Const.get? (↑(Std.DTreeMap.Internal.Impl.Const.insertManyIfNewUnit t l ⋯)) k =
if k ∈ t ∨ l.contains k = true then so... | null | true |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle.0.Real.Angle.two_nsmul_eq_iff._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ {ψ θ : Real.Angle}, (2 • ψ = 2 • θ) = (ψ = θ ∨ ψ = θ + ↑Real.pi) | null | false |
Part.Fix.approx._unsafe_rec | Mathlib.Control.Fix | {α : Type u_1} → {β : α → Type u_2} → (((a : α) → Part (β a)) → (a : α) → Part (β a)) → Stream' ((a : α) → Part (β a)) | null | false |
CategoryTheory.GradedObject.mapTrifunctorMap_obj | Mathlib.CategoryTheory.GradedObject.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] [inst_2 : CategoryTheory.Category.{v_3, u_3} C₃]
[inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor... | null | true |
FiniteDimensional.of_locallyCompactSpace | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ (𝕜 : Type u_4) [inst : NontriviallyNormedField 𝕜] [CompleteSpace 𝕜] {E : Type u_5} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [T2Space E] [IsTopologicalAddGroup E] [ContinuousSMul 𝕜 E]
[WeaklyLocallyCompactSpace E], FiniteDimensional 𝕜 E | **Riesz's theorem**: a locally compact topological vector space is finite-dimensional. | true |
ProjectiveSpectrum.ctorIdx | 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 𝒜} → ProjectiveSpectrum 𝒜 → ℕ | null | false |
MeasureTheory.Measure.MeasurableSet.nullMeasurableSet_subtype_coe | Mathlib.MeasureTheory.Measure.Restrict | ∀ {α : Type u_2} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {t : Set ↑s},
MeasureTheory.NullMeasurableSet s μ → MeasurableSet t → MeasureTheory.NullMeasurableSet (Subtype.val '' t) μ | null | true |
Ideal.uniqueUnits | Mathlib.RingTheory.Ideal.Operations | {R : Type u} → [inst : CommSemiring R] → Unique (Ideal R)ˣ | null | true |
rTensor.inverse_apply | Mathlib.LinearAlgebra.TensorProduct.RightExactness | ∀ {R : Type u_1} {M : Type u_2} {N : Type u_3} {P : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : AddCommGroup P] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R P]
{f : M →ₗ[R] N} {g : N →ₗ[R] P} (Q : Type u_5) [inst_7 : AddCommGroup Q] [inst_8 : Module ... | null | true |
Complex.range_sin | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | Set.range Complex.sin = Set.univ | null | true |
instAssociativeMinOnOfIsLinearPreorder | Init.Data.Order.MinMaxOn | ∀ {β : Type u_1} {α : Sort u_2} [inst : LE β] [inst_1 : DecidableLE β] [Std.IsLinearPreorder β] {f : α → β},
Std.Associative (minOn f) | null | true |
TopologicalSpace.NonemptyCompacts.instPartialOrder | Mathlib.Topology.Sets.Compacts | {α : Type u_1} → [inst : TopologicalSpace α] → PartialOrder (TopologicalSpace.NonemptyCompacts α) | null | true |
Lean.Expr.fvar.inj | Lean.Expr | ∀ {fvarId fvarId_1 : Lean.FVarId}, Lean.Expr.fvar fvarId = Lean.Expr.fvar fvarId_1 → fvarId = fvarId_1 | null | true |
_private.Std.Http.Data.Body.Stream.0.Std.Http.Body.Channel.State.mk.noConfusion | Std.Http.Data.Body.Stream | {P : Sort u} →
{pendingProducer : Option Std.Http.Body.Channel.Producer✝} →
{pendingConsumer : Option Std.Http.Body.Channel.Consumer✝} →
{interestWaiter : Option (Std.Async.Waiter Bool)} →
{closed : Bool} →
{knownSize : Option Std.Http.Body.Length} →
{pendingIncompleteChunk : O... | null | false |
AddOpposite.instDecidableEq | Mathlib.Algebra.Opposites | {α : Type u_1} → [DecidableEq α] → DecidableEq αᵃᵒᵖ | null | true |
OpenNormalAddSubgroup.toFiniteIndexNormalAddSubgroup._proof_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {G : Type u_1} [inst : AddGroup G] [inst_1 : TopologicalSpace G] [CompactSpace G] [ContinuousAdd G]
(H : OpenNormalAddSubgroup G), (↑H.toOpenAddSubgroup).FiniteIndex | null | false |
Lean.Grind.AC.Context.vars | Init.Grind.AC | {α : Sort u} → Lean.Grind.AC.Context α → Lean.RArray (PLift α) | null | true |
ContinuousMap.instRing._proof_8 | Mathlib.Topology.ContinuousMap.Algebra | ∀ {β : Type u_1} [inst : TopologicalSpace β] [inst_1 : Ring β] [IsTopologicalRing β], ContinuousNeg β | null | false |
CategoryTheory.InjectiveResolution.extEquivCohomologyClass._proof_6 | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C],
(HomologicalComplex.quasiIso C (ComplexShape.up ℤ)).IsCompatibleWithShift ℤ | null | false |
Filter.EventuallyEq.mapClusterPt_iff | Mathlib.Topology.ClusterPt | ∀ {X : Type u} [inst : TopologicalSpace X] {α : Type u_1} {F : Filter α} {u : α → X} {x : X} {v : α → X},
u =ᶠ[F] v → (MapClusterPt x F u ↔ MapClusterPt x F v) | null | true |
sbtw_const_vsub_iff | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] {x y z : P} (p : P), Sbtw R (p -ᵥ x) (p -ᵥ y) (p -ᵥ z) ↔ Sbtw R x y z | null | true |
CategoryTheory.WithTerminal.comp.eq_2 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : CategoryTheory.WithTerminal C) (_X : C),
CategoryTheory.WithTerminal.comp = fun _f _g => PUnit.unit | null | true |
CategoryTheory.sum.inrCompInrCompInverseAssociator_hom_app_down | Mathlib.CategoryTheory.Sums.Associator | ∀ (C : Type u₁) [inst : CategoryTheory.Category.{v₁, u₁} C] (D : Type u₂) [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(E : Type u₃) [inst_2 : CategoryTheory.Category.{v₃, u₃} E] (X : E),
((CategoryTheory.sum.inrCompInrCompInverseAssociator C D E).hom.app X).down =
CategoryTheory.CategoryStruct.comp (CategoryT... | null | true |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.updateDelImp.match_1 | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
(motive : Lean.Compiler.LCNF.Code pu → Sort u_1) →
(c : Lean.Compiler.LCNF.Code pu) →
((fvarId : Lean.FVarId) →
(k : Lean.Compiler.LCNF.Code pu) →
(h : pu = Lean.Compiler.LCNF.Purity.impure) → motive (Lean.Compiler.LCNF.Code.del fvarId k h)) →
... | null | false |
Lean.Parser.Tactic.Grind.finishTrace | Init.Grind.Interactive | Lean.ParserDescr | `finish?` tries to close the current goal using `grind`'s default strategy and suggests a tactic script. | true |
_private.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.0.PiTensorProduct.wrapped._proof_1._@.Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm.2741663271._hygCtx._hyg.2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.InjectiveSeminorm | @PiTensorProduct.definition✝ = @PiTensorProduct.definition✝ | null | false |
_private.Mathlib.RingTheory.Extension.Cotangent.Basis.0.Algebra.Generators.PresentationOfFreeCotangent.Aux.tensorCotangentInv._proof_2 | Mathlib.RingTheory.Extension.Cotangent.Basis | ∀ {R : Type u_1} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {ι : Type u_2}
{P : Algebra.Generators R S ι} {σ : Type u_4} {b : Module.Basis σ S P.toExtension.Cotangent}
(D : Algebra.Generators.PresentationOfFreeCotangent.Aux✝ P b),
SMulCommClass (Algebra.Generators.Presentation... | null | false |
CategoryTheory.Limits.pasteVertIsPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Pasting | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{Y₃ Y₂ Y₁ X₃ : C} →
{g₂ : Y₃ ⟶ Y₂} →
{g₁ : Y₂ ⟶ Y₁} →
{i₃ : Y₃ ⟶ X₃} →
{t₁ : CategoryTheory.Limits.PushoutCocone g₂ i₃} →
{i₂ : Y₂ ⟶ t₁.pt} →
{t₂ : CategoryTheory.Limits.PushoutCocone g₁ i₂... | Given
```
Y₃ - i₃ -> X₃
| |
g₂ f₂
∨ ∨
Y₂ - i₂ -> X₂
| |
g₁ f₁
∨ ∨
Y₁ - i₁ -> X₁
```
The big square is a pushout if both the small squares are.
| true |
CategoryTheory.MonoidalClosed.curry.eq_1 | Mathlib.CategoryTheory.LocallyCartesianClosed.Sections | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A X Y : C}
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry = ⇑((CategoryTheory.ihom.adjunction A).homEquiv Y X) | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalClear._regBuiltin.Lean.Elab.Tactic.evalClear.declRange_3 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.mkGrindEqnParams | Lean.Elab.Tactic.Try | Array Lean.Name → Lean.MetaM (Array (Lean.TSyntax `Lean.Parser.Tactic.grindParam)) | Given a set of declaration names, returns `grind` parameters of the form `= <declName>` | true |
Subtype.restrict_def | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} (f : α → β) (p : α → Prop), Subtype.restrict p f = f ∘ fun a => ↑a | null | true |
String.Pos.ofToSlice_comp_toSlice | Init.Data.String.Basic | ∀ {s : String}, String.Pos.ofToSlice ∘ String.Pos.toSlice = id | null | true |
Prod.mk_dvd_mk._simp_1 | Mathlib.Algebra.Divisibility.Prod | ∀ {G₁ : Type u_2} {G₂ : Type u_3} [inst : Semigroup G₁] [inst_1 : Semigroup G₂] {x₁ y₁ : G₁} {x₂ y₂ : G₂},
((x₁, x₂) ∣ (y₁, y₂)) = (x₁ ∣ y₁ ∧ x₂ ∣ y₂) | null | false |
Lean.Server.Completion.EligibleDecl.recOn | Lean.Server.Completion.EligibleHeaderDecls | {motive : Lean.Server.Completion.EligibleDecl → Sort u} →
(t : Lean.Server.Completion.EligibleDecl) →
((info : Lean.ConstantInfo) →
(kind : Lean.MetaM Lean.Lsp.CompletionItemKind) →
(tags : Lean.MetaM (Array Lean.Lsp.CompletionItemTag)) →
motive { info := info, kind := kind, tags := ... | null | false |
Vector.zip_replicate | Init.Data.Vector.Zip | ∀ {α : Type u_1} {β : Type u_2} {a : α} {b : β} {n : ℕ},
(Vector.replicate n a).zip (Vector.replicate n b) = Vector.replicate n (a, b) | null | true |
RelEmbedding.mul_apply | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (e₁ e₂ : r ↪r r) (x : α), (e₁ * e₂) x = e₁ (e₂ x) | null | true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategorySnd._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y : C) ⦃X_1 Y_1 : CategoryTheory.Over Y⦄ (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
(({ obj := fun Z => CategoryTheory.Over.mk (CategoryTheory.MonoidalCategoryStruct.whiskerLeft X Z... | null | false |
_private.Lean.Data.Lsp.LanguageFeatures.0.Lean.Lsp.instBEqInsertReplaceEdit.beq.match_1 | Lean.Data.Lsp.LanguageFeatures | (motive : Lean.Lsp.InsertReplaceEdit → Lean.Lsp.InsertReplaceEdit → Sort u_1) →
(x x_1 : Lean.Lsp.InsertReplaceEdit) →
((a : String) →
(a_1 a_2 : Lean.Lsp.Range) →
(b : String) →
(b_1 b_2 : Lean.Lsp.Range) →
motive { newText := a, insert := a_1, replace := a_2 } { newTe... | null | false |
_private.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.0.definition._simp_6._@.Mathlib.MeasureTheory.Measure.Typeclasses.Finite.1878421158._hygCtx._hyg.2 | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | ∀ {α : Type u} {x : α} {S : Set (Set α)}, (x ∈ ⋃₀ S) = ∃ t ∈ S, x ∈ t | null | false |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.oangle_incenter_eq._proof_1_1 | Mathlib.Geometry.Euclidean.Angle.Incenter | NeZero (1 + 1) | null | false |
ContinuousMap.HomotopicRel.equivalence | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X},
Equivalence fun f g => f.HomotopicRel g S | null | true |
CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation_I | Mathlib.CategoryTheory.Abelian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {P Q : C} (f : P ⟶ Q),
(CategoryTheory.Abelian.coimageStrongEpiMonoFactorisation f).I = CategoryTheory.Abelian.coimage f | null | true |
_private.Mathlib.Topology.Separation.Regular.0.regularSpace_TFAE.match_1_7 | Mathlib.Topology.Separation.Regular | ∀ (X : Type u_1) [inst : TopologicalSpace X]
(motive : (∀ (x : X), (nhds x).lift' closure = nhds x) → (x : X) → (x_1 : Set X) → x_1 ∈ nhds x → Prop)
(x : ∀ (x : X), (nhds x).lift' closure = nhds x) (x_1 : X) (x_2 : Set X) (x_3 : x_2 ∈ nhds x_1),
(∀ (H : ∀ (x : X), (nhds x).lift' closure = nhds x) (a : X) (s : Set... | null | false |
Int.natCast_le_zero._simp_1 | Init.Data.Int.LemmasAux | ∀ {n : ℕ}, (↑n ≤ 0) = (n = 0) | null | false |
_private.Mathlib.RingTheory.Congruence.Hom.0.RingCon.correspondence._simp_5 | Mathlib.RingTheory.Congruence.Hom | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R] {c d : RingCon R}, (c ≤ d) = ∀ {x y : R}, c x y → d x y | null | false |
SimpleGraph.Subgraph.IsMatching | Mathlib.Combinatorics.SimpleGraph.Matching | {V : Type u_1} → {G : SimpleGraph V} → G.Subgraph → Prop | The subgraph `M` of `G` is a matching if every vertex of `M` is incident to exactly one edge in `M`.
We say that the vertices in `M.support` are *matched* or *saturated*.
| true |
Finset.one_le_prod' | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {N : Type u_5} [inst : CommMonoid N] [inst_1 : Preorder N] {f : ι → N} {s : Finset ι} [MulLeftMono N],
(∀ i ∈ s, 1 ≤ f i) → 1 ≤ ∏ i ∈ s, f i | null | true |
Partition.Rel.trans | Mathlib.Order.Partition.Basic | ∀ {α : Type u_1} {x y z : α} {u : Set α} {P : Partition u}, P.Rel x y → P.Rel y z → P.Rel x z | null | true |
Std.Time.WallTime.addSeconds | Std.Time.DateTime.WallTime | Std.Time.WallTime → Std.Time.Second.Offset → Std.Time.WallTime | Adds a `Second.Offset` to the given `WallTime`.
| true |
FiniteAddGrp.instConcreteCategoryAddMonoidHomCarrierToAddGrp._aux_1 | Mathlib.Algebra.Category.Grp.FiniteGrp | {X Y : FiniteAddGrp.{u_1}} → (X ⟶ Y) → ↑X.toAddGrp →+ ↑Y.toAddGrp | null | false |
Lean.Grind.OrderedRing.mul_le_mul_of_nonneg_left | Init.Grind.Ordered.Ring | ∀ {R : Type u} [inst : Lean.Grind.Ring R] [inst_1 : LE R] [inst_2 : LT R] [inst_3 : Std.IsPartialOrder R]
[Lean.Grind.OrderedRing R] [Std.LawfulOrderLT R] {a b c : R}, a ≤ b → 0 ≤ c → c * a ≤ c * b | null | true |
CategoryTheory.ComposableArrows.Precomp.map._proof_7 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (i : ℕ) (hi : i + 1 < n + 1 + 1) (j : ℕ) (hj : j + 1 < n + 1 + 1), ⟨i + 1, hi⟩ ≤ ⟨j + 1, hj⟩ → i ≤ j | null | false |
Finset.le_truncatedSup | Mathlib.Combinatorics.SetFamily.AhlswedeZhang | ∀ {α : Type u_1} [inst : SemilatticeSup α] {s : Finset α} {a : α} [inst_1 : DecidableLE α] [inst_2 : OrderTop α],
a ≤ s.truncatedSup a | null | true |
_private.Mathlib.Topology.Homotopy.Product.0.Path.Homotopic.«_aux_Mathlib_Topology_Homotopy_Product___macroRules__private_Mathlib_Topology_Homotopy_Product_0_Path_Homotopic_term_⬝__1» | Mathlib.Topology.Homotopy.Product | Lean.Macro | null | false |
contDiffOn_of_analyticOn_of_fderivWithin | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {n : WithTop ℕ∞}, AnalyticOn 𝕜 f s → ContDiffOn 𝕜 ⊤ (fun y => fderivWithin 𝕜 f s y) s → C... | null | true |
RootPairing.Hom.mk.injEq | Mathlib.LinearAlgebra.RootSystem.Hom | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : CommRing R] [inst_1 : AddCommGroup M]
[inst_2 : Module R M] [inst_3 : AddCommGroup N] [inst_4 : Module R N] {ι₂ : Type u_5} {M₂ : Type u_6} {N₂ : Type u_7}
[inst_5 : AddCommGroup M₂] [inst_6 : Module R M₂] [inst_7 : AddCommGroup N₂] [inst_8 : Mod... | null | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic.0.WeierstrassCurve.Projective.nonsingular_some._simp_1_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Basic | ∀ {a b c : Prop}, (a ∧ b ↔ a ∧ c) = (a → (b ↔ c)) | null | false |
CochainComplex.HomComplex.coboundaries.eq_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n : ℤ),
CochainComplex.HomComplex.coboundaries K L n =
{ carrier := {α | ∃ m, ∃ (_ : m + 1 = n), ∃ β, CochainComplex.HomComplex.δ m n β = ↑α}, add_mem' := ⋯,
zero_mem' := ⋯, neg_mem... | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.quot._regBuiltin.Lean.Parser.Command.quot.declRange_5 | Lean.Parser.Command | IO Unit | null | false |
FreeAddGroup.reduceCyclically.reduce_flatten_replicate_succ | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)} [inst : DecidableEq α],
FreeAddGroup.IsReduced L →
∀ (n : ℕ),
FreeAddGroup.reduce (List.replicate (n + 1) L).flatten =
FreeAddGroup.reduceCyclically.conjugator L ++
(List.replicate (n + 1) (FreeAddGroup.reduceCyclically L)).flatten ++
FreeAd... | null | true |
SubMulAction.algebraMap_mem | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (r : R),
(algebraMap R A) r ∈ 1 | null | true |
IsCauSeq | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_3} →
[inst : Field α] →
[inst_1 : LinearOrder α] → [IsStrictOrderedRing α] → {β : Type u_4} → [Ring β] → (β → α) → (ℕ → β) → Prop | A sequence is Cauchy if the distance between its entries tends to zero. | true |
contDiffPointwiseHolderAt_iff | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] (k : ℕ) (α : ↑unitInterval) (f : E → F) (a : E),
ContDiffPointwiseHolderAt k α f a ↔
ContDiffAt ℝ (↑k) f a ∧ (fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f... | null | true |
_private.Init.Data.String.Lemmas.Order.0.String.Slice.Pos.next_eq_iff.match_1_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p q : s.Pos} (motive : (p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q') → Prop)
(x : p < q ∧ ∀ (q' : s.Pos), p < q' → q ≤ q'),
(∀ (h₁ : p < q) (h₂ : ∀ (q' : s.Pos), p < q' → q ≤ q'), motive ⋯) → motive x | null | false |
Set.singleton_union | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, {a} ∪ s = insert a s | null | true |
Trunc.nonempty | Mathlib.Data.Quot | ∀ {α : Sort u_1} (q : Trunc α), Nonempty α | null | true |
_private.Mathlib.Lean.Expr.Basic.0.Lean.Expr.type?._sparseCasesOn_1 | Mathlib.Lean.Expr.Basic | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → (Nat.hasNotBit 8 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Order.Sublattice.0.Sublattice.le_prod_iff._simp_1_1 | Mathlib.Order.Sublattice | ∀ {A : Type u_1} {B : Type u_2} [inst : SetLike A B] [inst_1 : LE A] [IsConcreteLE A B] {S T : A},
(S ≤ T) = ∀ ⦃x : B⦄, x ∈ S → x ∈ T | null | false |
fderivWithin_csinh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E},
DifferentiableWithinAt ℂ f s x →
UniqueDiffWithinAt ℂ s x →
fderivWithin ℂ (fun x => Complex.sinh (f x)) s x = Complex.cosh (f x) • fderivWithin ℂ f s x | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.