name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Nat.ofDigits_lt_base_pow_length' | Mathlib.Data.Nat.Digits.Defs | ∀ {b : ℕ} {l : List ℕ}, (∀ x ∈ l, x < b + 2) → Nat.ofDigits (b + 2) l < (b + 2) ^ l.length | an n-digit number in base b + 2 is less than (b + 2)^n | true |
String.Pos.next.eq_1 | Init.Data.String.Basic | ∀ {s : String} (pos : s.Pos) (h : pos ≠ s.endPos), pos.next h = String.Pos.ofToSlice (pos.toSlice.next ⋯) | null | true |
Std.Internal.List.getValueCast!_filter | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : LawfulBEq α] {f : (a : α) → β a → Bool}
{l : List ((a : α) × β a)} {k : α} [inst_2 : Inhabited (β k)],
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getValueCast! k (List.filter (fun p => f p.fst p.snd) l) =
(Option.filter (f k) (Std.Internal... | null | true |
_private.Mathlib.Topology.Homeomorph.Defs.0.Homeomorph.isInducing._simp_1_1 | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} [inst : TopologicalSpace X], Topology.IsInducing id = True | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.CommRing.RingId.0.Lean.Meta.Grind.Arith.CommRing.getCommRingId?.goCore? | Lean.Meta.Tactic.Grind.Arith.CommRing.RingId | Lean.Expr → Lean.Meta.Grind.GoalM (Option ℕ) | null | true |
Lean.Server.RequestHandlerCompleteness.rec | Lean.Server.Requests | {motive : Lean.Server.RequestHandlerCompleteness → Sort u} →
motive Lean.Server.RequestHandlerCompleteness.complete →
((refreshMethod : String) →
(refreshIntervalMs : ℕ) →
motive (Lean.Server.RequestHandlerCompleteness.partial refreshMethod refreshIntervalMs)) →
(t : Lean.Server.RequestHan... | null | false |
cfcₙHomTransfer._proof_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Transfer | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} {q : B → Prop} [inst : CommSemiring R] [inst_1 : NonUnitalRing A]
[inst_2 : StarRing A] [inst_3 : Module R A] [inst_4 : NonUnitalRing B] [inst_5 : StarRing B] [inst_6 : Module R B]
(e : A ≃⋆ₐ[R] B) (b : B), q b → q (e (e.symm b)) | null | false |
CategoryTheory.PreGaloisCategory.IsFundamentalGroup.rec | Mathlib.CategoryTheory.Galois.IsFundamentalgroup | {C : Type u₁} →
[inst : CategoryTheory.Category.{u₂, u₁} C] →
{F : CategoryTheory.Functor C FintypeCat} →
[inst_1 : CategoryTheory.GaloisCategory C] →
{G : Type u_1} →
[inst_2 : Group G] →
[inst_3 : (X : C) → MulAction G (F.obj X).obj] →
[inst_4 : TopologicalSpace... | null | false |
Lean.LBool.false.elim | Lean.Data.LBool | {motive : Lean.LBool → Sort u} → (t : Lean.LBool) → t.ctorIdx = 0 → motive Lean.LBool.false → motive t | null | false |
String.Slice.dropPrefix_char_eq_dropPrefix_beq | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice}, s.dropPrefix c = s.dropPrefix fun x => x == c | null | true |
TopologicalSpace.Opens.mapId._proof_3 | Mathlib.Topology.Category.TopCat.Opens | ∀ (X : TopCat),
CategoryTheory.CategoryStruct.comp { app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ }
{ app := fun U => CategoryTheory.eqToHom ⋯, naturality := ⋯ } =
CategoryTheory.CategoryStruct.id (TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)) | null | false |
WeierstrassCurve.Affine.CoordinateRing.quotientXYIdealEquiv._proof_3 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Point | ∀ {R : Type u_1} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} {x : R} {y : Polynomial R},
(Ideal.map (Ideal.Quotient.mkₐ R (Ideal.span {W'.polynomial}))
(Ideal.span {Polynomial.C (Polynomial.X - Polynomial.C x), Polynomial.X - Polynomial.C y})).IsTwoSided | null | false |
CategoryTheory.IsKernelPair.equivalenceRelation._proof_1 | Mathlib.CategoryTheory.EquivalenceRelation | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) f | null | false |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.instLawfulToForwardSearcherModelForallCharPropDefaultForwardSearcherForallBoolDecide._simp_1 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos : s.Pos}
{l : List (String.Slice.Pattern.SearchStep s)},
String.Slice.Pattern.Model.IsValidSearchFrom p pos l =
String.Slice.Pattern.Model.IsValidSearchFrom (fun x => decide (p x)) pos l | null | false |
midpoint_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : Ring 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜]
[inst_3 : AddCommGroup E] [inst_4 : Module 𝕜 E] [inst_5 : Invertible 2] (x y : E), midpoint 𝕜 x y ∈ segment 𝕜 x y | null | true |
CategoryTheory.Monad.Algebra.Hom.mk.congr_simp | Mathlib.CategoryTheory.Monad.Algebra | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {T : CategoryTheory.Monad C} {A B : T.Algebra}
(f f_1 : A.A ⟶ B.A) (e_f : f = f_1)
(h : CategoryTheory.CategoryStruct.comp (T.map f) B.a = CategoryTheory.CategoryStruct.comp A.a f),
{ f := f, h := h } = { f := f_1, h := ⋯ } | null | true |
_private.Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition.0.Submodule.rank_le_one_iff_isPrincipal._simp_1_1 | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
[Module.Free K V], (Module.rank K V ≤ 1) = ∃ v₀, ∀ (v : V), ∃ r, r • v₀ = v | null | false |
upperBounds_prod | Mathlib.Order.Bounds.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β},
s.Nonempty → t.Nonempty → upperBounds (s ×ˢ t) = upperBounds s ×ˢ upperBounds t | null | true |
Algebra.Generators.Hom.mk.sizeOf_spec | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Generators R S ι} {R' : Type u_1} {S' : Type u_2} {ι' : Type u_3} [inst_3 : CommRing R']
[inst_4 : CommRing S'] [inst_5 : Algebra R' S'] {P' : Algebra.Generators R' S' ι'} [inst_6 : Algebra S S']
... | null | true |
_private.Lean.Compiler.LCNF.Visibility.0.Lean.Compiler.LCNF.markDeclPublicRec.match_1 | Lean.Compiler.LCNF.Visibility | (phase : Lean.Compiler.LCNF.Phase) →
(motive : Option (Lean.Compiler.LCNF.Decl phase.toPurity) → Sort u_1) →
(__do_lift : Option (Lean.Compiler.LCNF.Decl phase.toPurity)) →
((refDecl : Lean.Compiler.LCNF.Decl phase.toPurity) → motive (some refDecl)) →
((x : Option (Lean.Compiler.LCNF.Decl phase.toPu... | null | false |
_private.Lean.Meta.Tactic.Subst.0.Lean.Meta.subst.match_3 | Lean.Meta.Tactic.Subst | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((val : Lean.Expr × Lean.Expr × Lean.Expr) → motive (some val)) → (Unit → motive none) → motive __do_lift | null | false |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {motive : Fin (n + 1) → Sort u_1} {succ : (i : Fin n) → motive i.succ → motive i.castSucc} (i : Fin n) (j : ℕ)
(h : j < n + 1) (h2 : ↑i < j) (zero : motive ⟨j, h⟩),
Fin.reverseInduction.go succ i.castSucc j h ⋯ zero = succ i (Fin.reverseInduction.go succ i.succ j h h2 zero) | null | true |
RootPairing.smul_coroot_eq_of_root_eq_smul | Mathlib.LinearAlgebra.RootSystem.Defs | ∀ {ι : 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] {P : RootPairing ι R M N} [Finite ι]
[HasUniqueDiv N] (i j : ι) (t : R), P.root j = t • P.root i → t • P.coroot j = P.coroot i | null | true |
_private.Lean.Meta.Tactic.Grind.Theorems.0.Lean.Meta.Grind.Theorems.insert._sparseCasesOn_7 | Lean.Meta.Tactic.Grind.Theorems | {motive : Lean.HeadIndex → Sort u} →
(t : Lean.HeadIndex) →
((constName : Lean.Name) → motive (Lean.HeadIndex.const constName)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
Finset.mem_powersetCard._simp_1 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u_1} {n : ℕ} {s t : Finset α}, (s ∈ Finset.powersetCard n t) = (s ⊆ t ∧ s.card = n) | null | false |
BoxIntegral.Prepartition.instOrderTop | Mathlib.Analysis.BoxIntegral.Partition.Basic | {ι : Type u_1} → {I : BoxIntegral.Box ι} → OrderTop (BoxIntegral.Prepartition I) | null | true |
CategoryTheory.LocalizerMorphism.arrow | Mathlib.CategoryTheory.Localization.LocalizerMorphism | {C₁ : Type u₁} →
{C₂ : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
{W₁ : CategoryTheory.MorphismProperty C₁} →
{W₂ : CategoryTheory.MorphismProperty C₂} →
CategoryTheory.LocalizerMorphism W₁ W₂ → CategoryTheory.Loca... | The localizer morphism from `W₁.arrow` to `W₂.arrow` that is induced by
`Φ : LocalizerMorphism W₁ W₂`. | true |
Lean.Lsp.instToJsonRange | Lean.Data.Lsp.BasicAux | Lean.ToJson Lean.Lsp.Range | null | true |
Units.instMulDistribMulAction._proof_2 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {M : Type u_1} {α : Type u_2} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction M α] (m : Mˣ)
(b₁ b₂ : α), ↑m • (b₁ * b₂) = ↑m • b₁ * ↑m • b₂ | null | false |
Affine.Simplex.faceOpposite | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | {k : Type u_1} →
{V : Type u_2} →
{P : Type u_5} →
[inst : Ring k] →
[inst_1 : AddCommGroup V] →
[inst_2 : Module k V] →
[inst_3 : AddTorsor V P] →
{n : ℕ} → [NeZero n] → Affine.Simplex k P n → Fin (n + 1) → Affine.Simplex k P (n - 1) | The face of a simplex with all but one point. | true |
UniformSpace.hausdorff._proof_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ (α : Type u_1) [inst : UniformSpace α],
Filter.Tendsto Prod.swap ((uniformity α).lift' hausdorffEntourage) ((uniformity α).lift' hausdorffEntourage) | null | false |
DirectSum.decomposeAlgEquiv_apply | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {R : Type u_2} {A : Type u_3} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : CommSemiring R]
[inst_3 : Semiring A] [inst_4 : Algebra R A] (𝒜 : ι → Submodule R A) [inst_5 : GradedAlgebra 𝒜] (a : A),
(DirectSum.decomposeAlgEquiv 𝒜) a = (DirectSum.decompose 𝒜) a | null | true |
CategoryTheory.δ_naturality_assoc | Mathlib.CategoryTheory.Monoidal.End | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {M : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} M]
[inst_2 : CategoryTheory.MonoidalCategory M] (F : CategoryTheory.Functor M (CategoryTheory.Functor C C)) {m n : M}
{X Y : C} (f : X ⟶ Y) [inst_3 : F.OplaxMonoidal] {Z : C} (h : (F.obj n).obj ((F.o... | null | true |
symmDiff_symmDiff_cancel_left | Mathlib.Order.SymmDiff | ∀ {α : Type u_2} [inst : GeneralizedBooleanAlgebra α] (a b : α), symmDiff a (symmDiff a b) = b | null | true |
NumberField.instCommRingAdeleRing._proof_25 | Mathlib.NumberTheory.NumberField.AdeleRing | ∀ (R : Type u_1) (K : Type u_2) [inst : CommRing R] [inst_1 : IsDedekindDomain R] [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (a : NumberField.AdeleRing R K), a * 0 = 0 | null | false |
PMF.binomial_apply_zero | Mathlib.Probability.ProbabilityMassFunction.Binomial | ∀ (p : NNReal) (h : p ≤ 1) (n : ℕ), (PMF.binomial p h n) 0 = (1 - ↑p) ^ n | null | true |
Ne.dite_ne_right_iff | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} {P : Prop} [inst : Decidable P] {b : α} {A : P → α},
(∀ (h : P), A h ≠ b) → ((dite P A fun x => b) ≠ b ↔ P) | null | true |
Std.HashMap.size_insertIfNew | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {k : α}
{v : β}, (m.insertIfNew k v).size = if k ∈ m then m.size else m.size + 1 | null | true |
CategoryTheory.EnrichedCat.bicategory._proof_14 | Mathlib.CategoryTheory.Enriched.EnrichedCat | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.MonoidalCategory V]
{a b c d : CategoryTheory.EnrichedCat V} {f f' : CategoryTheory.EnrichedFunctor V ↑a ↑b} (η : f ⟶ f')
(g : CategoryTheory.EnrichedFunctor V ↑b ↑c) (h : CategoryTheory.EnrichedFunctor V ↑c ↑d),
CategoryTheor... | null | false |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.go._unary._proof_11 | Init.Data.String.Pattern.String | ∀ (pat : String.Slice) (table : Array ℕ), 0 < table.size → table.size - 1 < table.size | null | false |
SSet.horn₃₁.desc | Mathlib.AlgebraicTopology.SimplicialSet.HornColimits | {X : SSet} →
(f₀ f₂ f₃ : SSet.stdSimplex.obj { len := 2 } ⟶ X) →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 2) f₀ =
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 0) f₃ →
CategoryTheory.CategoryStruct.comp (SSet.stdSimplex.δ 1) f₀ =
CategoryTheory.CategoryStruct.comp (SSe... | The morphism `Λ[3, 1] ⟶ X` which is obtained by gluing three
morphisms `Δ[2] ⟶ X`. | true |
BoundedContinuousFunction._aux_Mathlib_Topology_ContinuousMap_Bounded_Basic___unexpand_BoundedContinuousFunction_1 | Mathlib.Topology.ContinuousMap.Bounded.Basic | Lean.PrettyPrinter.Unexpander | null | false |
NormedAlgebra.restrictScalars._proof_1 | Mathlib.Analysis.Normed.Module.Basic | ∀ (𝕜 : Type u_2) (𝕜' : Type u_3) (E : Type u_1) [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] [inst_3 : SeminormedRing E] [inst_4 : NormedAlgebra 𝕜' E] (r : 𝕜) (x : E),
(algebraMap 𝕜 E) r * x = x * (algebraMap 𝕜 E) r | null | false |
IsHomeomorph.surjective | Mathlib.Topology.Homeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsHomeomorph f → Function.Surjective f | null | true |
_private.Mathlib.Basic.Sign.Defs.0._proof_15 | Mathlib.Basic.Sign.Defs | ∀ (x : SignType), SignType.enumList[x.ctorIdx]? = some x | null | false |
_private.Batteries.Data.List.Basic.0.List.dropSlice_zero₂.match_1_1 | Batteries.Data.List.Basic | ∀ {α : Type u_1} (motive : ℕ → List α → Prop) (x : ℕ) (x_1 : List α),
(∀ (_ : Unit), motive 0 []) →
(∀ (head : α) (tail : List α), motive 0 (head :: tail)) →
(∀ (n : ℕ), motive n.succ []) → (∀ (n : ℕ) (x : α) (xs : List α), motive n.succ (x :: xs)) → motive x x_1 | null | false |
_private.Mathlib.Data.List.Pairwise.0.List.pairwise_iff_forall_infix._proof_1_7 | Mathlib.Data.List.Pairwise | ∀ {α : Type u_1} (l' : List α), 1 < l'.length → ∀ (l₂ : List α), l'.length - 1 < (l' ++ l₂).length | null | false |
CategoryTheory.Iso.inv_ext' | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : X ≅ Y} {g : Y ⟶ X},
CategoryTheory.CategoryStruct.comp f.hom g = CategoryTheory.CategoryStruct.id X → g = f.inv | null | true |
List.Vector.«_aux_Mathlib_Data_Vector_Basic___macroRules_List_Vector_term_::ᵥ__1» | Mathlib.Data.Vector.Basic | Lean.Macro | null | false |
_private.Mathlib.Tactic.ClickSuggestions.GRewrite.0.Mathlib.Tactic.ClickSuggestions.dummyDischarger._sparseCasesOn_5 | Mathlib.Tactic.ClickSuggestions.GRewrite | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
ContinuousOn.image_Icc_of_antitoneOn | Mathlib.Topology.Order.IntermediateValue | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : ConditionallyCompleteLinearOrder α] [OrderTopology α]
[DenselyOrdered α] {δ : Type u_1} [inst_4 : LinearOrder δ] [inst_5 : TopologicalSpace δ] [OrderClosedTopology δ]
{a b : α} {f : α → δ},
a ≤ b → ContinuousOn f (Set.Icc a b) → AntitoneOn f (Set.Icc a b) → f '... | null | true |
LieAlgebra.IsExtension.casesOn | Mathlib.Algebra.Lie.Extension | {R : Type u_1} →
{N : Type u_2} →
{L : Type u_3} →
{M : Type u_4} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] →
[inst_3 : LieRing N] →
[inst_4 : LieAlgebra R N] →
[inst_5 : LieRing M] →
... | null | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.renameFunAuxImage.match_1 | Mathlib.RingTheory.MvPowerSeries.Rename | {σ : Type u_2} →
{τ : Type u_1} →
(motive : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ) → Sort u_3) →
(x : ((τ →₀ ℕ) × (τ →₀ ℕ)) × (σ →₀ ℕ) × (σ →₀ ℕ)) →
((fst : (τ →₀ ℕ) × (τ →₀ ℕ)) → (b : (σ →₀ ℕ) × (σ →₀ ℕ)) → motive (fst, b)) → motive x | null | false |
Polynomial.reflect.match_1 | Mathlib.Algebra.Polynomial.Reverse | {R : Type u_1} →
[inst : Semiring R] →
(motive : Polynomial R → Sort u_2) →
(x : Polynomial R) → ((f : AddMonoidAlgebra R ℕ) → motive { toFinsupp := f }) → motive x | null | false |
cfcHom_predicate | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | null | true |
_private.Init.Data.List.ToArray.0.List.findSomeRevM?_find_toArray | Init.Data.List.ToArray | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] [LawfulMonad m] (f : α → m (Option β))
(l : List α) (i : ℕ) (h : i ≤ l.toArray.size),
Array.findSomeRevM?.find✝ f l.toArray i h = List.findSomeM? f (List.take i l).reverse | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.inner_eq_norm_mul_norm_mul_cos_oangle._simp_1_7 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
ContinuousLinearEquiv.submoduleMap._proof_2 | Mathlib.Topology.Algebra.Module.Equiv.Submodule | ∀ {R : Type u_3} {M : Type u_1} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : TopologicalSpace M] {R₂ : Type u_4} {M₂ : Type u_2} [inst_4 : Semiring R₂] [inst_5 : AddCommMonoid M₂]
[inst_6 : TopologicalSpace M₂] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} {σ₂₁ : R₂ →+* R}
{re₁₂ : Rin... | null | false |
apply_dite | Init.ByCases | ∀ {α : Sort u_1} {β : Sort u_2} (f : α → β) (P : Prop) [inst : Decidable P] (x : P → α) (y : ¬P → α),
f (dite P x y) = if h : P then f (x h) else f (y h) | A function applied to a `dite` is a `dite` of that function applied to each of the branches. | true |
_private.Mathlib.Order.Fin.Tuple.0.Fin.liftFun_cons.match_1_1 | Mathlib.Order.Fin.Tuple | ∀ {α : Type u_1} (motive : (n : ℕ) → {f : Fin n → α} → Prop) (n : ℕ) {f : Fin n → α},
(∀ (f : Fin 0 → α), motive 0) → (∀ (n : ℕ) (f : Fin (n + 1) → α), motive n.succ) → motive n | null | false |
Matrix.normedAddCommGroup._proof_6 | Mathlib.Analysis.Matrix.Normed | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : Fintype m] [inst_1 : Fintype n] [inst_2 : NormedAddCommGroup α],
autoParam ((Bornology.cobounded (Matrix m n α)).sets = {s | ∃ C, ∀ x ∈ sᶜ, ∀ y ∈ sᶜ, dist x y ≤ C})
PseudoMetricSpace.cobounded_sets._autoParam | null | false |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_105 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Matrix.mul_one | Mathlib.Data.Matrix.Mul | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : NonAssocSemiring α] [inst_1 : Fintype n] [inst_2 : DecidableEq n]
(M : Matrix m n α), M * 1 = M | null | true |
Std.IterM.TerminationMeasures.Productive.casesOn | Init.Data.Iterators.Basic | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{motive : Std.IterM.TerminationMeasures.Productive α m → Sort u} →
(t : Std.IterM.TerminationMeasures.Productive α m) → ((it : Std.IterM m β) → motive { it := it }) → motive t | null | false |
Monoid.End.ext | Mathlib.Algebra.Group.Hom.Defs | ∀ (M : Type u_4) [inst : MulOne M] {f g : Monoid.End M}, (∀ (x : M), f x = g x) → f = g | null | true |
ContDiffMapSupportedIn.zero_on_compl | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | ∀ {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {n : ℕ∞} {K : TopologicalSpace.Compacts E} (f : ContDiffMapSupportedIn E F n K),
Set.EqOn (⇑f) 0 (↑K)ᶜ | null | true |
Set.image2_inter_union_subset | Mathlib.Data.Set.NAry | ∀ {α : Type u_1} {β : Type u_3} {f : α → α → β} {s t : Set α},
(∀ (a b : α), f a b = f b a) → Set.image2 f (s ∩ t) (s ∪ t) ⊆ Set.image2 f s t | null | true |
Set.Icc_add_Ico_subset | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Add α] [inst_1 : PartialOrder α] [AddLeftStrictMono α] [AddRightStrictMono α] (a b c d : α),
Set.Icc a b + Set.Ico c d ⊆ Set.Ico (a + c) (b + d) | null | true |
Lean.Grind.Linarith.instBEqPoly.beq._sunfold | Init.Grind.Ordered.Linarith | Lean.Grind.Linarith.Poly → Lean.Grind.Linarith.Poly → Bool | null | false |
WithAbs.instRing._proof_3 | Mathlib.Analysis.Normed.Ring.WithAbs | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring S] [inst_1 : PartialOrder S] [inst_2 : Ring R] (v : AbsoluteValue R S),
autoParam (∀ (n : ℕ) (a : WithAbs v), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | null | false |
Con.monoid._proof_4 | Mathlib.GroupTheory.Congruence.Defs | ∀ {M : Type u_1} [inst : Monoid M] (c : Con M), autoParam (∀ (x : c.Quotient), x ^ 0 = 1) Monoid.npow_zero._autoParam | null | false |
TopologicalSpace.le_generateFrom_iff_subset_isOpen | Mathlib.Topology.Order | ∀ {α : Type u} {g : Set (Set α)} {t : TopologicalSpace α}, t ≤ TopologicalSpace.generateFrom g ↔ g ⊆ {s | IsOpen s} | null | true |
_private.Mathlib.NumberTheory.EulerProduct.DirichletLSeries.0.log_riemannZeta_eq._simp_1_3 | Mathlib.NumberTheory.EulerProduct.DirichletLSeries | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
DomMulAct.instDistribMulActionSubtypeAEEqFunMemAddSubgroupLp | Mathlib.MeasureTheory.Function.LpSpace.DomAct.Basic | {M : Type u_1} →
{α : Type u_3} →
{E : Type u_4} →
[inst : MeasurableSpace α] →
[inst_1 : NormedAddCommGroup E] →
{μ : MeasureTheory.Measure α} →
{p : ENNReal} →
[inst_2 : Monoid M] →
[inst_3 : MulAction M α] →
[MeasureTheory.SMul... | null | true |
Fin.castSucc_pos | Init.Data.Fin.Lemmas | ∀ {n : ℕ} [inst : NeZero n] {i : Fin n}, 0 < i → 0 < i.castSucc | `castSucc i` is positive when `i` is positive | true |
instInfiniteSubtypeMemSubgroupOfIsCyclicOfNontrivial | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ {G : Type u_2} [Infinite G] [inst : Group G] [IsCyclic G] {H : Subgroup G} [h : Nontrivial ↥H], Infinite ↥H | null | true |
Std.PRange.UpwardEnumerable.least | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u_1} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : Std.PRange.Least? α] → [Std.PRange.LawfulUpwardEnumerableLeast? α] → [hn : Nonempty α] → α | null | true |
CategoryTheory.Limits.IsLimit.assoc._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryFan | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {sXY : CategoryTheory.Limits.BinaryFan X Y}
{sYZ : CategoryTheory.Limits.BinaryFan Y Z} (P : CategoryTheory.Limits.IsLimit sXY)
(Q : CategoryTheory.Limits.IsLimit sYZ) {s : CategoryTheory.Limits.BinaryFan sXY.pt Z}
(R : CategoryTheory.Limi... | null | false |
Sym.map_mk._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_2} {β : Type u_1} {n : ℕ} {f : α → β} {m : Multiset α} {hc : m.card = n}, (Multiset.map f m).card = n | null | false |
Function.HasTemperateGrowth.toTemperedDistribution._proof_6 | Mathlib.Analysis.Distribution.TemperedDistribution | RingHomCompTriple (RingHom.id ℂ) (RingHom.id ℂ) (RingHom.id ℂ) | null | false |
Mathlib.Tactic.Linarith.applyContrLemma | Mathlib.Tactic.Linarith.Frontend | Lean.MVarId → Lean.MetaM (Option (Lean.Expr × Lean.Expr) × Lean.MVarId) | `applyContrLemma` inspects the target to see if it can be moved to a hypothesis by negation.
For example, a goal `⊢ a ≤ b` can become `b < a ⊢ false`.
If this is the case, it applies the appropriate lemma and introduces the new hypothesis.
It returns the type of the terms in the comparison (e.g. the type of `a` and `b`... | true |
Pi.spectrum_eq | Mathlib.Algebra.Algebra.Spectrum.Pi | ∀ {ι : Type u_1} {R : Type u_4} {κ : ι → Type u_5} [inst : CommSemiring R] [inst_1 : (i : ι) → Ring (κ i)]
[inst_2 : (i : ι) → Algebra R (κ i)] (a : (i : ι) → κ i), spectrum R a = ⋃ i, spectrum R (a i) | null | true |
ProofWidgets.RefreshComponent.RefreshState.recOn | ProofWidgets.Component.RefreshComponent | {motive : ProofWidgets.RefreshComponent.RefreshState → Sort u} →
(t : ProofWidgets.RefreshComponent.RefreshState) →
((curr : Thunk ProofWidgets.Html) →
(idx : ℕ) → (next : Task (Option Unit)) → motive { curr := curr, idx := idx, next := next }) →
motive t | null | false |
Path.Homotopic.Quotient.symm | Mathlib.Topology.Homotopy.Path | {X : Type u} → [inst : TopologicalSpace X] → {x₀ x₁ : X} → Path.Homotopic.Quotient x₀ x₁ → Path.Homotopic.Quotient x₁ x₀ | The reverse of a path homotopy class. This is `Path.symm` descended to the quotient. | true |
StarAlgEquiv.arrowCongr'_refl | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_1} {A₁ : Type u_2} {A₂ : Type u_3} [inst : Monoid R] [inst_1 : NonUnitalNonAssocSemiring A₁]
[inst_2 : DistribMulAction R A₁] [inst_3 : Star A₁] [inst_4 : NonUnitalNonAssocSemiring A₂]
[inst_5 : DistribMulAction R A₂] [inst_6 : Star A₂],
(StarAlgEquiv.refl R A₁).arrowCongr' (StarAlgEquiv.refl R A₂) ... | null | true |
CategoryTheory.Limits.FormalCoproduct.powerMap_id | Mathlib.CategoryTheory.Limits.FormalCoproducts.Cech | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (U : CategoryTheory.Limits.FormalCoproduct C) (α : Type t)
[inst_1 : CategoryTheory.Limits.HasProductsOfShape α C],
CategoryTheory.Limits.FormalCoproduct.powerMap (CategoryTheory.CategoryStruct.id U) α =
CategoryTheory.CategoryStruct.id (U.power α) | null | true |
Lean.«binderPred⊃_» | Init.BinderPredicates | Lean.ParserDescr | Declare `∀ x ⊃ y, ...` as syntax for `∀ x, x ⊃ y → ...` and `∃ x ⊃ y, ...` as syntax for
`∃ x, x ⊃ y ∧ ...` | true |
_private.Lean.Parser.Term.Doc.0.Lean.Parser.Term.Doc.getRecommendedSpellingsForName.match_4 | Lean.Parser.Term.Doc | (motive : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling) → Sort u_1) →
(x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) →
((strs : Array Lean.Parser.Term.Doc.RecommendedSpelling) → motive (some strs)) →
((x : Option (Array Lean.Parser.Term.Doc.RecommendedSpelling)) → motive x) → motive... | null | false |
CategoryTheory.InjectiveResolution.isoRightDerivedObj_hom_naturality_assoc | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u_1} [inst_1 : CategoryTheory.Category.{v_1, u_1} D]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.HasInjectiveResolutions C]
[inst_4 : CategoryTheory.Abelian D] {X Y : C} (f : X ⟶ Y) (I : CategoryTheory.InjectiveResolution X)
(J : ... | null | true |
Lean.Elab.Term.CollectPatternVars.Context.casesOn | Lean.Elab.PatternVar | {motive : Lean.Elab.Term.CollectPatternVars.Context → Sort u} →
(t : Lean.Elab.Term.CollectPatternVars.Context) →
((funId : Lean.Ident) →
(ctorVal? : Option Lean.ConstructorVal) →
(explicit ellipsis : Bool) →
(paramDecls : Array (Lean.Name × Lean.BinderInfo)) →
(paramDe... | null | false |
Lean.Lsp.InitializeParams.processId?._default | Lean.Data.Lsp.InitShutdown | Option ℤ | null | false |
MonoidAlgebra.ext | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] {x y : MonoidAlgebra R M}, x.coeff = y.coeff → x = y | **Alias** of the forward direction of `MonoidAlgebra.coeff_inj`. | true |
ContinuousMultilinearMap.opNorm_prod | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ {𝕜 : Type u} {ι : Type v} {E : ι → Type wE} {G : Type wG} {G' : Type wG'} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : SeminormedAddCommGroup G']
[inst_6 ... | null | true |
ImportGraph.Shake.getResetNewExtraRevModUse | ImportGraph.Shake.EnvExtension | Lean.Environment →
optParam Lean.EnvExtension.AsyncMode ImportGraph.Shake.isExtraRevModUseExtAsyncMode →
optParam Lean.Name Lean.Name.anonymous → Bool × Lean.Environment | Gets and resets the state of the `extraModUses` extension. | true |
Std.Rci.mk.inj | Init.Data.Range.Polymorphic.PRange | ∀ {α : Type u} {lower lower_1 : α}, lower...* = lower_1...* → lower = lower_1 | null | true |
_private.Lean.Elab.Command.0.Lean.Elab.Command.StatefulLinter.mk.injEq | Lean.Elab.Command | ∀ {σ τ : Type} (idx idx_1 : ℕ), ({ idx := idx } = { idx := idx_1 }) = (idx = idx_1) | null | true |
ContinuousAlgEquiv.isUniformEmbedding | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} [inst : CommSemiring R] {E₁ : Type u_5} {E₂ : Type u_6} [inst_1 : UniformSpace E₁]
[inst_2 : UniformSpace E₂] [inst_3 : Ring E₁] [IsUniformAddGroup E₁] [inst_5 : Algebra R E₁] [inst_6 : Ring E₂]
[IsUniformAddGroup E₂] [inst_8 : Algebra R E₂] (e : E₁ ≃A[R] E₂), IsUniformEmbedding ⇑e | null | true |
RootedTree.mk.injEq | Mathlib.Order.SuccPred.Tree | ∀ (α : Type u_2) [semilatticeInf : SemilatticeInf α] [orderBot : OrderBot α] [predOrder : PredOrder α]
[isPredArchimedean : IsPredArchimedean α] (α_1 : Type u_2) (semilatticeInf_1 : SemilatticeInf α_1)
(orderBot_1 : OrderBot α_1) (predOrder_1 : PredOrder α_1) (isPredArchimedean_1 : IsPredArchimedean α_1),
({ α :=... | null | true |
Lean.Kernel.Exception.unknownConstant.inj | Lean.Environment | ∀ {env : Lean.Kernel.Environment} {name : Lean.Name} {env_1 : Lean.Kernel.Environment} {name_1 : Lean.Name},
Lean.Kernel.Exception.unknownConstant env name = Lean.Kernel.Exception.unknownConstant env_1 name_1 →
env = env_1 ∧ name = name_1 | null | true |
Primrec.cond | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {σ : Type u_3} [inst : Primcodable α] [inst_1 : Primcodable σ] {c : α → Bool} {f g : α → σ},
Primrec c → Primrec f → Primrec g → Primrec fun a => bif c a then f a else g a | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.