name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.List.Nat.Modify.0.List.eraseIdx_modify_of_lt._proof_1_1 | Init.Data.List.Nat.Modify | ∀ {α : Type u_1} (f : α → α) (i j : ℕ) (l : List α), j < i → ∀ (k : ℕ), i - 1 = k → k < j → ¬i = k → False | null | false |
MeasureTheory.IsSigmaSubadditiveSetFun | Mathlib.MeasureTheory.Measure.PreVariation | {X : Type u_1} → [MeasurableSpace X] → (Set X → ENNReal) → Prop | A set function is σ-subadditive on measurable sets if the value assigned to the union of a
countable disjoint family of measurable sets is bounded above by the sum of values on the family. | true |
Std.TreeMap.getKeyD_maxKey! | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] [inst : Inhabited α],
t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.maxKey! fallback = t.maxKey! | null | true |
_private.Init.Data.String.Lemmas.Iterate.0.String.Slice.mem_toList_copy_iff_exists_get._simp_1_1 | Init.Data.String.Lemmas.Iterate | ∀ {s : String.Slice}, s.copy.toList = List.map (fun p => (↑p).get ⋯) (String.Slice.Model.positionsFrom s.startPos) | null | false |
CartanMatrix.Generators.F.sizeOf_spec | Mathlib.Algebra.Lie.SerreConstruction | ∀ {B : Type v} [inst : SizeOf B] (a : B), sizeOf (CartanMatrix.Generators.F a) = 1 + sizeOf a | null | true |
List.foldr_flip_eq_foldl | Mathlib.Data.List.Fold | ∀ {α : Type u_1} {β : Type u_2} {l : List α} {v : β → α → β} {b : β} [RightCommutative v],
List.foldr (flip v) b l = List.foldl v b l | **Second Bird–Wadler duality theorem**. | true |
IterateAddAct.instMeasurableSpace.eq_1 | Mathlib.MeasureTheory.MeasurableSpace.Instances | ∀ {α : Type u_1} {f : α → α}, IterateAddAct.instMeasurableSpace = ⊤ | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Dihedral.0.DihedralGroup.center_eq_bot_of_odd_ne_one._proof_1_3 | Mathlib.GroupTheory.SpecificGroups.Dihedral | ∀ {n : ℕ}, Odd n → n ≠ 1 → 1 < n | null | false |
CategoryTheory.InjectiveResolution.add_extMk | Mathlib.CategoryTheory.Abelian.Injective.Ext | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (R : CategoryTheory.InjectiveResolution Y) {n : ℕ}
(f g : X ⟶ R.cocomplex.X n) (m : ℕ) (hm : n + 1 = m)
(hf : CategoryTheory.CategoryStruct.comp f (R.cocomplex.d n m) = 0)
(h... | null | true |
DiffeologicalSpace.CorePlotsOn.mk.inj | Mathlib.Geometry.Diffeology.Basic | ∀ {X : Type u_1}
{isPlotOn : {n : ℕ} → {u : Set (EuclideanSpace ℝ (Fin n))} → IsOpen u → (EuclideanSpace ℝ (Fin n) → X) → Prop}
{isPlotOn_congr :
∀ {n : ℕ} {u : Set (EuclideanSpace ℝ (Fin n))} (hu : IsOpen u) {p q : EuclideanSpace ℝ (Fin n) → X},
Set.EqOn p q u → (isPlotOn hu p ↔ isPlotOn hu q)}
{isPlot... | null | true |
PowerSeries.WithPiTopology.multipliable_one_add_of_tendsto_order_atTop_nhds_top | Mathlib.RingTheory.PowerSeries.PiTopology | ∀ (R : Type u_1) [inst : TopologicalSpace R] [inst_1 : CommSemiring R] {ι : Type u_2} [inst_2 : LinearOrder ι]
[LocallyFiniteOrderBot ι] {f : ι → PowerSeries R},
Filter.Tendsto (fun i => (f i).order) Filter.atTop (nhds ⊤) → Multipliable fun x => 1 + f x | A family of `PowerSeries` in the form `1 + f i` is multipliable if the order of `f i` tends to
infinity. | true |
RBTree.RBNode.foldr.eq_2 | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {σ : Sort u_2} (f : α → σ → σ) (x : σ) (c : RBTree.RBColor) (l : RBTree.RBNode α) (v : α)
(r : RBTree.RBNode α),
RBTree.RBNode.foldr f (RBTree.RBNode.node c l v r) x = RBTree.RBNode.foldr f l (f v (RBTree.RBNode.foldr f r x)) | null | true |
Std.Roo.HasRcoIntersection.ctorIdx | Init.Data.Range.Polymorphic.PRange | {α : Type w} → Std.Roo.HasRcoIntersection α → ℕ | null | false |
Batteries.Random.MersenneTwister.State.twist | Batteries.Data.Random.MersenneTwister | {cfg : Batteries.Random.MersenneTwister.Config} →
Batteries.Random.MersenneTwister.State cfg → Batteries.Random.MersenneTwister.State cfg | Apply the twisting transformation to the given state. | true |
Valuation.Integers.not_denselyOrdered_of_isPrincipalIdealRing | Mathlib.RingTheory.Valuation.Integers | ∀ {F : Type u} {Γ₀ : Type v} [inst : Field F] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] {v : Valuation F Γ₀}
{O : Type w} [inst_2 : CommRing O] [inst_3 : Algebra O F] [IsPrincipalIdealRing O],
v.Integers O → ¬DenselyOrdered ↑(Set.range ⇑v) | null | true |
LinearMap.extendScalarsOfIsLocalizationEquiv_apply | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_3} [inst : CommSemiring R] (S : Submonoid R) (A : Type u_4) [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] [inst_3 : IsLocalization S A] {M : Type u_5} {N : Type u_6} [inst_4 : AddCommMonoid M]
[inst_5 : Module R M] [inst_6 : Module A M] [inst_7 : IsScalarTower R A M] [inst_8 : AddCommMonoid N]
[i... | null | true |
Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context.semiringId | Lean.Meta.Tactic.Grind.Arith.CommRing.NonCommSemiringM | Lean.Meta.Grind.Arith.CommRing.NonCommSemiringM.Context → ℕ | null | true |
TopCat.GlueData.MkCore.t'._proof_7 | Mathlib.Topology.Gluing | ∀ (h : TopCat.GlueData.MkCore) (i j k : h.J),
Continuous fun x =>
⟨(⟨↑((CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1), ⋯⟩,
(CategoryTheory.ConcreteCategory.hom (h.t i j)) (↑x).1),
⋯⟩ | null | false |
NonUnitalStarAlgHom.realContinuousMapZeroOfNNReal._proof_8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unique | ∀ {X : Type u_2} [inst : TopologicalSpace X] [inst_1 : Zero X] {A : Type u_1} [inst_2 : NonUnitalRing A]
[inst_3 : StarRing A] [inst_4 : Module ℝ A] (φ : ContinuousMapZero X NNReal →⋆ₙₐ[NNReal] A)
(f : ContinuousMapZero X ℝ), φ (star f).toNNReal - φ (-star f).toNNReal = star (φ f.toNNReal - φ (-f).toNNReal) | null | false |
Eq.ndrec_symm.congr_simp | Init.Grind.Ring.CommSolver | ∀ {α : Sort u2} {a : α} {motive : α → Sort u1} (m m_1 : motive a),
m = m_1 → ∀ {b : α} (h : b = a), Eq.ndrec_symm m h = Eq.ndrec_symm m_1 h | null | true |
Subalgebra.unop_iSup | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : ι → Subalgebra R Aᵐᵒᵖ), (iSup S).unop = ⨆ i, (S i).unop | null | true |
Fin.decodeProd_encodeProd | Batteries.Data.Fin.Coding | ∀ {m n : ℕ} (x : Fin m × Fin n), Fin.decodeProd (Fin.encodeProd x) = x | null | true |
List.max_le_of_forall_le | Mathlib.Data.List.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : OrderBot α] (l : List α) (a : α),
(∀ x ∈ l, x ≤ a) → List.foldr max ⊥ l ≤ a | null | true |
sSupHom.mk.noConfusion | Mathlib.Order.Hom.CompleteLattice | {α : Type u_8} →
{β : Type u_9} →
{inst : SupSet α} →
{inst_1 : SupSet β} →
{P : Sort u} →
{toFun : α → β} →
{map_sSup' : ∀ (s : Set α), toFun (sSup s) = sSup (toFun '' s)} →
{toFun' : α → β} →
{map_sSup'' : ∀ (s : Set α), toFun' (sSup s) = sSup (t... | null | false |
Prod.snd_bot | Mathlib.Order.BoundedOrder.Basic | ∀ (α : Type u) (β : Type v) [inst : Bot α] [inst_1 : Bot β], ⊥.2 = ⊥ | null | true |
Array.elem_push_self | Init.Data.Array.Lemmas | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : Array α} {a : α}, Array.elem a (xs.push a) = true | null | true |
Mathlib.Meta.Positivity.evalPowZeroNat | Mathlib.Tactic.Positivity.Basic | Mathlib.Meta.Positivity.PositivityExt | The `positivity` extension which identifies expressions of the form `a ^ (0 : ℕ)`.
This extension is run in addition to the general `a ^ b` extension (they are overlapping). | true |
LibraryNote.category_theory_universes | Mathlib.CategoryTheory.Category.Basic | Batteries.Util.LibraryNote | The typeclass `Category C` describes morphisms associated to objects of type `C : Type u`.
The universe levels of the objects and morphisms are independent, and will often need to be
specified explicitly, as `Category.{v} C`.
Typically any concrete example will either be a `SmallCategory`, where `v = u`,
which can be... | true |
_private.Mathlib.Data.Ordmap.Invariants.0.Ordnode.Bounded.weak_right.match_1_1 | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α]
(motive : (x : Ordnode α) → (x_1 : WithBot α) → (x_2 : WithTop α) → x.Bounded x_1 x_2 → Prop) (x : Ordnode α)
(x_1 : WithBot α) (x_2 : WithTop α) (x_3 : x.Bounded x_1 x_2),
(∀ (o₁ : WithBot α) (o₂ : WithTop α) (h : Ordnode.nil.Bounded o₁ o₂), motive Ordnode.nil o₁ o₂ h) →
... | null | false |
AList.erase.eq_1 | Mathlib.Data.Finmap | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] (a : α) (s : AList β),
AList.erase a s = { entries := List.kerase a s.entries, nodupKeys := ⋯ } | null | true |
Equiv.subtypePreimage._proof_7 | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_2} {β : Sort u_1} (p : α → Prop) [inst : DecidablePred p] (x₀ : { a // p a } → β) (x : α → β)
(hx : x ∘ Subtype.val = x₀) (a : α),
↑((fun x => ⟨fun a => if h : p a then x₀ ⟨a, h⟩ else x ⟨a, h⟩, ⋯⟩) ((fun x a => ↑x ↑a) ⟨x, hx⟩)) a = ↑⟨x, hx⟩ a | null | false |
RingEquiv.map_neg_one | Mathlib.Algebra.Ring.Equiv | ∀ {R : Type u_4} {S : Type u_5} [inst : NonAssocRing R] [inst_1 : NonAssocRing S] (f : R ≃+* S), f (-1) = -1 | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.RingId.0.Lean.Meta.Grind.Arith.CommRing.getCommSemiringId?.go? | Lean.Meta.Tactic.Grind.Arith.CommRing.RingId | Lean.Expr → Lean.Meta.Grind.GoalM (Option ℕ) | null | true |
Lean.Elab.HeaderProcessedSnapshot.noConfusionType | Lean.Elab.DefView | Sort u → Lean.Elab.HeaderProcessedSnapshot → Lean.Elab.HeaderProcessedSnapshot → Sort u | null | false |
Std.ExtTreeMap.get_union_of_not_mem_left | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α}
(not_mem : k ∉ t₁) {h' : k ∈ t₁ ∪ t₂}, (t₁ ∪ t₂).get k h' = t₂.get k ⋯ | null | true |
Lean.instReprSMap | Lean.Data.SMap | {α : Type u_1} → {β : Type u_2} → {x : BEq α} → {x_1 : Hashable α} → [Repr α] → [Repr β] → Repr (Lean.SMap α β) | null | true |
_private.Init.Data.List.Nat.Count.0.List.countP_replace._proof_1_6 | Init.Data.List.Nat.Count | ∀ {α : Type u_1} [BEq α] {a : α} {b : α} {p : α → Bool} (x : α) (l : List α),
(¬((List.countP p l + if p b = true then 1 else 0) + if p x = true then 1 else 0) =
(List.countP p l + if p x = true then 1 else 0) + if p b = true then 1 else 0) →
False | null | false |
CategoryTheory.LaxMonoidalFunctor.hom_ext | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F G : CategoryTheory.LaxMonoidalFunctor C D} {α β : F ⟶ G}, α.hom = β.hom → α = β | null | true |
Multiset.sum_map_sub | Mathlib.Algebra.BigOperators.Group.Multiset.Basic | ∀ {ι : Type u_2} {G : Type u_4} [inst : SubtractionCommMonoid G] {m : Multiset ι} {f g : ι → G},
(Multiset.map (fun i => f i - g i) m).sum = (Multiset.map f m).sum - (Multiset.map g m).sum | null | true |
Std.DTreeMap.Internal.RxcIterator.mk.noConfusion | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
{inst : Ord α} →
{P : Sort u_1} →
{iter : Std.DTreeMap.Internal.Zipper α β} →
{upper : α} →
{iter' : Std.DTreeMap.Internal.Zipper α β} →
{upper' : α} →
{ iter := iter, upper := upper } = { iter := iter', upper := u... | null | false |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.δ_comp_δ._proof_1_1 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ (i k : ℕ), k < i → i ≤ k → False | null | false |
_private.Mathlib.RingTheory.Valuation.Discrete.Basic.0.Valuation.Uniformizer.is_generator._simp_1_2 | Mathlib.RingTheory.Valuation.Discrete.Basic | (¬True) = False | null | false |
FractionalIdeal.definition._proof_3._@.Mathlib.RingTheory.FractionalIdeal.Operations.2078496209._hygCtx._hyg.2 | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] (S : Submonoid R), Submonoid.map (RingEquiv.refl R).toMonoidHom S = S | null | false |
Polynomial.evalEval_neg | Mathlib.Algebra.Polynomial.Bivariate | ∀ {R : Type u_1} [inst : Ring R] (x y : R) (p : Polynomial (Polynomial R)),
Polynomial.evalEval x y (-p) = -Polynomial.evalEval x y p | null | true |
Order.pred_le_iff_eq_or_le | Mathlib.Order.SuccPred.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : PredOrder α] {a b : α}, Order.pred b ≤ a ↔ a = Order.pred b ∨ b ≤ a | null | true |
summable_pnat_iff_summable_succ | Mathlib.Topology.Algebra.InfiniteSum.NatInt | ∀ {M : Type u_1} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] {f : ℕ → M},
(Summable fun x => f ↑x) ↔ Summable fun x => f (x + 1) | null | true |
CentroidHom.commRing | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} →
[inst : NonUnitalRing α] → (∀ (a b : α), (∀ (r : α), a * r * b = 0) → a = 0 ∨ b = 0) → CommRing (CentroidHom α) | A prime associative ring has commutative centroid. | true |
ProbabilityTheory.HasGaussianLaw.fst | Mathlib.Probability.Distributions.Gaussian.HasGaussianLaw.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {F : Type u_3} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω}
[inst : NormedAddCommGroup E] [inst_1 : MeasurableSpace E] [BorelSpace E] {X : Ω → E} [inst_3 : NormedSpace ℝ E]
[inst_4 : NormedAddCommGroup F] [inst_5 : NormedSpace ℝ F] [inst_6 : MeasurableSpace F] {Y : Ω → F},
... | null | true |
Rat.instEncodable._proof_1 | Mathlib.Data.Rat.Encodable | ∀ (a : ℤ) (b : ℕ), b ≠ 0 → a.natAbs.Coprime b → 0 < b ∧ a.natAbs.Coprime b | null | false |
HomologicalComplex.mapBifunctor₂₃.d₁_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
NNRat.castHom | Mathlib.Data.Rat.Cast.CharZero | (α : Type u_3) → [inst : DivisionSemiring α] → [CharZero α] → ℚ≥0 →+* α | Coercion `ℚ≥0 → α` as a `RingHom`. | true |
_private.Mathlib.Geometry.Manifold.Notation.0.Manifold.Elab.findModelInner.fromCLM.match_1 | Mathlib.Geometry.Manifold.Notation | (motive : Lean.Expr × Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr × Lean.Expr) → ((k _E _F : Lean.Expr) → motive (k, _E, _F)) → motive __discr | null | false |
CategoryTheory.Abelian.Ext.precompOfLinear._proof_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X : C} (R : Type u_1) [inst_3 : CommRing R] [inst_4 : CategoryTheory.Linear R C]
(Z : C) {b : ℕ}, SMulCommClass R R (CategoryTheory.Abelian.Ext X Z b) | null | false |
USize.pow._f | Init.Data.UInt.Basic | USize → (n : ℕ) → Nat.below n → USize | null | false |
_private.Lean.Server.Completion.CompletionCollectors.0.Lean.Server.Completion.addUnresolvedCompletionItem | Lean.Server.Completion.CompletionCollectors | Lean.Name →
Lean.Lsp.CompletionIdentifier →
Lean.Lsp.CompletionItemKind → Array Lean.Lsp.CompletionItemTag → Lean.Server.Completion.M✝ Unit | Adds a new completion item with the given `label`, `id`, `kind` and `score` to the state in `M`.
Computes the doc string from the environment if available.
| true |
_private.Mathlib.Analysis.Meromorphic.Divisor.0.MeromorphicOn.divisor._simp_12 | Mathlib.Analysis.Meromorphic.Divisor | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
ProofWidgets.RpcEncodablePacket._@.ProofWidgets.Presentation.Expr.4196812879._hygCtx._hyg.1 | ProofWidgets.Presentation.Expr | Type | null | false |
_private.Mathlib.Geometry.Euclidean.Sphere.SecondInter.0.EuclideanGeometry.Sphere.secondInter_map._simp_1_2 | Mathlib.Geometry.Euclidean.Sphere.SecondInter | ∀ {𝕜 : Type u_1} {V : Type u_2} {V₂ : Type u_5} {P : Type u_10} {P₂ : Type u_11} [inst : NormedField 𝕜]
[inst_1 : SeminormedAddCommGroup V] [inst_2 : NormedSpace 𝕜 V] [inst_3 : PseudoMetricSpace P]
[inst_4 : NormedAddTorsor V P] [inst_5 : SeminormedAddCommGroup V₂] [inst_6 : NormedSpace 𝕜 V₂]
[inst_7 : Pseudo... | null | false |
CategoryTheory.MorphismProperty.instCompleteBooleanAlgebra._proof_15 | Mathlib.CategoryTheory.MorphismProperty.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.CategoryStruct.{u_1, u_2} C] (x : ⦃X Y : C⦄ → (X ⟶ Y) → Prop), ⊤ ≤ x ⊔ xᶜ | null | false |
Lean.PrettyPrinter.Parenthesizer.State.rec | Lean.PrettyPrinter.Parenthesizer | {motive : Lean.PrettyPrinter.Parenthesizer.State → Sort u} →
((stxTrav : Lean.Syntax.Traverser) →
(contPrec : Option ℕ) →
(contCat : Lean.Name) →
(minPrec trailPrec : Option ℕ) →
(trailCat : Lean.Name) →
(visitedToken : Bool) →
motive
... | null | false |
_private.Init.Data.String.OrderInstances.0.String.Pos.Raw.instTotalLe._simp_6 | Init.Data.String.OrderInstances | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
instSigmaCompactSpaceForallOfFinite | Mathlib.Topology.Compactness.SigmaCompact | ∀ {ι : Type u_3} [Finite ι] {X : ι → Type u_4} [inst : (i : ι) → TopologicalSpace (X i)]
[∀ (i : ι), SigmaCompactSpace (X i)], SigmaCompactSpace ((i : ι) → X i) | null | true |
ordinaryHypergeometricSeries.congr_simp | Mathlib.Analysis.SpecialFunctions.OrdinaryHypergeometric | ∀ {𝕂 : Type u_1} (𝔸 : Type u_2) [inst : Field 𝕂] [inst_1 : Ring 𝔸] [inst_2 : Algebra 𝕂 𝔸] [inst_3 : TopologicalSpace 𝔸]
[inst_4 : IsTopologicalRing 𝔸] (a a_1 : 𝕂),
a = a_1 →
∀ (b b_1 : 𝕂),
b = b_1 →
∀ (c c_1 : 𝕂),
c = c_1 → ∀ (n : ℕ), ordinaryHypergeometricSeries 𝔸 a b c n = ... | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey_minKeyD._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
AlgebraicGeometry.Scheme.Hom.image_le_image_iff | Mathlib.AlgebraicGeometry.OpenImmersion | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.IsOpenImmersion f] (U U' : X.Opens),
(AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U ≤ (AlgebraicGeometry.Scheme.Hom.opensFunctor f).obj U' ↔ U ≤ U' | null | true |
SignType | Mathlib.Data.Sign.Defs | Type | The type of signs. | true |
NormedAddGroupHom.ker.lift._proof_2 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_3} {V₂ : Type u_1} {V₃ : Type u_2} [inst : SeminormedAddCommGroup V₁]
[inst_1 : SeminormedAddCommGroup V₂] [inst_2 : SeminormedAddCommGroup V₃] (f : NormedAddGroupHom V₁ V₂)
(g : NormedAddGroupHom V₂ V₃) (h : g.comp f = 0) (v w : V₁), ⟨f (v + w), ⋯⟩ = ⟨f v, ⋯⟩ + ⟨f w, ⋯⟩ | null | false |
AddSubgroup.instNormalCenter | Mathlib.GroupTheory.Subgroup.Center | ∀ {G : Type u_1} [inst : AddGroup G], (AddSubgroup.center G).Normal | null | true |
AlgEquiv.ofRingEquiv.congr_simp | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type uR} {A₁ : Type uA₁} {A₂ : Type uA₂} [inst : CommSemiring R] [inst_1 : Semiring A₁] [inst_2 : Semiring A₂]
[inst_3 : Algebra R A₁] [inst_4 : Algebra R A₂] {f f_1 : A₁ ≃+* A₂} (e_f : f = f_1)
(hf : ∀ (x : R), f ((algebraMap R A₁) x) = (algebraMap R A₂) x), AlgEquiv.ofRingEquiv hf = AlgEquiv.ofRingEquiv ⋯ | null | true |
List.splitLengths.eq_def | Mathlib.Data.List.SplitLengths | ∀ {α : Type u_1} (x : List ℕ) (x_1 : List α),
x.splitLengths x_1 =
match x, x_1 with
| [], x => []
| n :: ns, x =>
match List.splitAt n x with
| (x0, x1) => x0 :: ns.splitLengths x1 | null | true |
LieRing.recOn | Mathlib.Algebra.Lie.Basic | {L : Type v} →
{motive : LieRing L → Sort u} →
(t : LieRing L) →
([toAddCommGroup : AddCommGroup L] →
[toBracket : Bracket L L] →
(add_lie : ∀ (x y z : L), ⁅x + y, z⁆ = ⁅x, z⁆ + ⁅y, z⁆) →
(lie_add : ∀ (x y z : L), ⁅x, y + z⁆ = ⁅x, y⁆ + ⁅x, z⁆) →
(lie_self ... | null | false |
normedAddCommGroupTangentSpaceVectorSpace._aux_8 | Mathlib.Geometry.Manifold.Riemannian.Basic | {E : Type u_1} →
[inst : NormedAddCommGroup E] →
[inst_1 : NormedSpace ℝ E] → (x : E) → Dist (TangentSpace (modelWithCornersSelf ℝ E) x) | null | false |
_private.Init.Data.String.Defs.0.String.Slice.Pos.byte._simp_1 | Init.Data.String.Defs | ∀ {s : String.Slice} {x y : s.Pos}, (x = y) = (x.offset = y.offset) | null | false |
Int8.toISize_lt._simp_1 | Init.Data.SInt.Lemmas | ∀ {a b : Int8}, (a.toISize < b.toISize) = (a < b) | null | false |
CategoryTheory.ShortComplex.SnakeInput.snd_δ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd S.L₁.g S.v₀₁.τ₃) S.δ =
CategoryTheory.CategoryStruct.comp S.φ₁ S.v₂₃.τ₁ | null | true |
OrderEmbedding.locallyFiniteOrder._proof_6 | Mathlib.Order.Interval.Finset.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : LocallyFiniteOrder β] (f : α ↪o β)
(a b : α), Set.InjOn (⇑f.toEmbedding) (⇑f ⁻¹' ↑(Finset.Ico (f a) (f b))) | null | false |
PerfectionMap.id | Mathlib.RingTheory.Perfection | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (R : Type u₁) [inst_1 : CommSemiring R] [inst_2 : CharP R p]
[inst_3 : PerfectRing R p], PerfectionMap p (RingHom.id R) | For a perfect ring, it itself is the perfection. | true |
Multiset.fold_cons_left | Mathlib.Data.Multiset.Fold | ∀ {α : Type u_1} (op : α → α → α) [hc : Std.Commutative op] [ha : Std.Associative op] (b a : α) (s : Multiset α),
Multiset.fold op b (a ::ₘ s) = op a (Multiset.fold op b s) | null | true |
Aesop.NormSeqResult.proved.noConfusion | Aesop.Search.Expansion.Norm | {P : Sort u} →
{script script' : Array (Aesop.DisplayRuleName × Option (Array Aesop.Script.LazyStep))} →
Aesop.NormSeqResult.proved script = Aesop.NormSeqResult.proved script' → (script = script' → P) → P | null | false |
LightProfinite.equivDiagram | Mathlib.Topology.Category.LightProfinite.Basic | LightProfinite ≌ LightDiagram | The equivalence of categories `LightProfinite ≌ LightDiagram` | true |
Lean.Meta.Sym.Simp.Result.isContextDependent.match_1 | Lean.Meta.Sym.Simp.SimpM | (motive : Lean.Meta.Sym.Simp.Result → Sort u_1) →
(x : Lean.Meta.Sym.Simp.Result) →
((done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.rfl done cd)) →
((e' proof : Lean.Expr) → (done cd : Bool) → motive (Lean.Meta.Sym.Simp.Result.step e' proof done cd)) → motive x | null | false |
RelIso.trans._proof_1 | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_3} {β : Type u_1} {γ : Type u_2} {r : α → α → Prop} {s : β → β → Prop} {t : γ → γ → Prop} (f₁ : r ≃r s)
(f₂ : s ≃r t) {a b : α}, t (f₂ (f₁.toEquiv a)) (f₂ (f₁.toEquiv b)) ↔ r a b | null | false |
_private.Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski.0.AlgebraicGeometry.Scheme.AffineZariskiSite.coequifibered_iff_forall_isLocalizationAway.match_1_5 | Mathlib.AlgebraicGeometry.Sites.SmallAffineZariski | ∀ {X : AlgebraicGeometry.Scheme} (x : X.AffineZariskiSiteᵒᵖ) (motive : (x_1 : X.AffineZariskiSiteᵒᵖ) → (x_1 ⟶ x) → Prop)
(x_1 : X.AffineZariskiSiteᵒᵖ) (x_2 : x_1 ⟶ x),
(∀ (V : X.AffineZariskiSite) (x : Opposite.op V ⟶ x), motive (Opposite.op V) x) → motive x_1 x_2 | null | false |
UInt64.sub_eq_iff_eq_add | Init.Data.UInt.Lemmas | ∀ {a b c : UInt64}, a - b = c ↔ a = c + b | null | true |
Derivation.noConfusion | Mathlib.RingTheory.Derivation.Basic | {P : Sort u} →
{R : Type u_1} →
{A : Type u_2} →
{M : Type u_3} →
{inst : CommSemiring R} →
{inst_1 : CommSemiring A} →
{inst_2 : AddCommMonoid M} →
{inst_3 : Algebra R A} →
{inst_4 : Module A M} →
{inst_5 : Module R M} →
... | null | false |
VectorFourier.fderiv_fourierIntegral | Mathlib.Analysis.Fourier.FourierTransformDeriv | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {V : Type u_2} {W : Type u_3}
[inst_2 : NormedAddCommGroup V] [inst_3 : NormedSpace ℝ V] [inst_4 : NormedAddCommGroup W] [inst_5 : NormedSpace ℝ W]
(L : V →L[ℝ] W →L[ℝ] ℝ) {f : V → E} [inst_6 : MeasurableSpace V] [BorelSpace V] [SecondCountab... | null | true |
ContinuousLinearMap.mulLeftRight._proof_12 | Mathlib.Analysis.Normed.Operator.Mul | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] (R : Type u_2) [inst_1 : NonUnitalSeminormedRing R]
[inst_2 : NormedSpace 𝕜 R], ContinuousConstSMul 𝕜 (R →L[𝕜] R) | null | false |
CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj_symm_apply | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {F : CategoryTheory.Functor C (Type w)} {X Y : C}
(e : Y ≅ X) (R : F.CorepresentableBy Y),
(CategoryTheory.Functor.CorepresentableBy.equivOfIsoObj e).symm R = R.ofIsoObj e.symm | null | true |
HomeomorphClass.coe_coe | Mathlib.Topology.Homeomorph.Defs | ∀ {F : Type u_5} {α : Type u_6} {β : Type u_7} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β]
[inst_2 : EquivLike F α β] [h : HomeomorphClass F α β] (f : F), ⇑↑f = ⇑f | null | true |
_private.Mathlib.Tactic.Cases.0.Mathlib.Tactic._aux_Mathlib_Tactic_Cases___elabRules_Mathlib_Tactic_induction'_1.match_4 | Mathlib.Tactic.Cases | (motive : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId) → Sort u_1) →
(__discr : Array Lean.Expr × Array (Lean.Ident × Lean.FVarId)) →
((targets : Array Lean.Expr) → (toTag : Array (Lean.Ident × Lean.FVarId)) → motive (targets, toTag)) →
motive __discr | null | false |
CategoryTheory.Functor.PullbackObjObj.π_iso_of_iso_left_inv | 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₃]
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} {f₁ f₁' : CategoryTheory.Arrow C₁}
{f₃ : CategoryTheory.Arrow C... | null | true |
Std.Roi.LawfulRcoIntersection.mk._flat_ctor | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type w} [inst : LT α] [inst_1 : LE α] [inst_2 : Std.Roi.HasRcoIntersection α],
(∀ {a : α} {r : Std.Roi α} {s : Std.Rco α}, a ∈ Std.Roi.HasRcoIntersection.intersection r s ↔ a ∈ r ∧ a ∈ s) →
Std.Roi.LawfulRcoIntersection α | null | false |
List.mapIdx.go.match_1 | Init.Data.List.MapIdx | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → Array β → Sort u_3) →
(x : List α) →
(x_1 : Array β) →
((acc : Array β) → motive [] acc) →
((a : α) → (as : List α) → (acc : Array β) → motive (a :: as) acc) → motive x x_1 | null | false |
Int.lcm_dvd_lcm_mul_right_right | Init.Data.Int.Gcd | ∀ (a b c : ℤ), a.lcm b ∣ a.lcm (b * c) | null | true |
CategoryTheory.SmallObject.SuccStruct.arrowι._proof_1 | Mathlib.CategoryTheory.SmallObject.Iteration.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : LinearOrder J]
[CategoryTheory.Limits.HasIterationOfShape J C] {i : J} (F : CategoryTheory.Functor (↑(Set.Iio i)) C),
Order.IsSuccLimit i → CategoryTheory.Limits.HasColimit F | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.Finset.image_subset_iff._simp_1 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {α : Type u_1} {β : Type u_2} [inst : DecidableEq β] {f : α → β} {s : Finset α} {t : Finset β},
(Finset.image f s ⊆ t) = ∀ x ∈ s, f x ∈ t | null | false |
HasFDerivWithinAt.congr' | Mathlib.Analysis.Calculus.FDeriv.Congr | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] {f f₁ : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt ... | null | true |
monovary_id_iff._simp_1 | Mathlib.Order.Monotone.Monovary | ∀ {ι : Type u_1} {α : Type u_3} [inst : Preorder α] {f : ι → α} [inst_1 : PartialOrder ι], Monovary f id = Monotone f | null | false |
_private.Batteries.Data.Char.Basic.0.Char.any._proof_1 | Batteries.Data.Char.Basic | ∀ c < Char.max - Char.maxSurrogate, 57343 < c + 57343 + 1 ∧ c + 57343 + 1 < 1114112 | null | false |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.FirstByte.utf8ByteSize.match_1.eq_3 | Init.Data.String.Decode | ∀ (motive : ByteArray.utf8DecodeChar?.FirstByte → Sort u_1)
(h_1 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.invalid)
(h_2 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.done)
(h_3 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.oneMore)
(h_4 : Unit → motive ByteArray.utf8DecodeChar?.FirstByte.... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.