name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Const.get?_congr | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {a b : α}, (a == b) = true → Std.DHashMap.Const.get? m a = Std.DHashMap.Const.get? m b | null | true |
_private.Batteries.Util.ProofWanted.0.elabWanted.match_13 | Batteries.Util.ProofWanted | (motive : (Lean.TSyntax `ident × WantedRefInfo✝) × Bool → Sort u_1) →
(x : (Lean.TSyntax `ident × WantedRefInfo✝) × Bool) →
((e : Lean.TSyntax `ident × WantedRefInfo✝) → (k : Bool) → motive (e, k)) → motive x | null | false |
TopModuleCat.instSMulHom._proof_1 | Mathlib.Algebra.Category.ModuleCat.Topology.Basic | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] {X : TopModuleCat S}, ContinuousAdd ↑X.1 | null | false |
Array.scanlM.eq_1 | Batteries.Data.Array.Scan | ∀ {m : Type u_1 → Type u_2} {β : Type u_1} {α : Type u_3} [inst : Monad m] (f : β → α → m β) (init : β) (as : Array α)
(start stop : ℕ),
Array.scanlM f init as start stop = Array.scanlM.loop f init as (min start as.size) (min stop as.size) ⋯ #[] | null | true |
TopologicalSpace.IrreducibleCloseds.map._proof_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] (f : β → α),
Continuous f → ∀ (c : TopologicalSpace.IrreducibleCloseds β), IsIrreducible (closure (f '' ↑c)) | null | false |
CompHausLike.LocallyConstant.counitAppApp._proof_5 | Mathlib.Condensed.Discrete.LocallyConstant | ∀ {P : TopCat → Prop} [inst : ∀ (S : CompHausLike P) (p : ↑S.toTop → Prop), CompHausLike.HasProp P (Subtype p)]
[inst_1 : CompHausLike.HasProp P PUnit.{u_1 + 1}] (S : CompHausLike P)
(Y : CategoryTheory.Functor (CompHausLike P)ᵒᵖ (Type (max u_1 u_2)))
(r : LocallyConstant (↑S.toTop) (Y.obj (Opposite.op ↧PUnit.{u_... | null | false |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.completeOmittedBody._unsafe_rec | Std.Http.Protocol.H1 | {dir : Std.Http.Protocol.H1.Direction} → Std.Http.Protocol.H1.Machine dir → Std.Http.Protocol.H1.Machine dir | null | false |
_private.Mathlib.Tactic.DefEqTransformations.0.Mathlib.Tactic.getProjectedExpr.match_7 | Mathlib.Tactic.DefEqTransformations | (motive : Option Lean.ProjectionFunctionInfo → Sort u_1) →
(__do_lift : Option Lean.ProjectionFunctionInfo) →
((info : Lean.ProjectionFunctionInfo) → motive (some info)) →
((x : Option Lean.ProjectionFunctionInfo) → motive x) → motive __do_lift | null | false |
ProfiniteGrp.toLimitFun._proof_6 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Limits | ∀ (P : ProfiniteGrp.{u_1}) (x x_1 : ↑P.toProfinite.toTop),
⟨fun x_2 => ↑(x * x_1), ⋯⟩ = ⟨fun x_2 => ↑x, ⋯⟩ * ⟨fun x => ↑x_1, ⋯⟩ | null | false |
CategoryTheory.Square.IsPullback.unop | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Square | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {sq : CategoryTheory.Square Cᵒᵖ},
sq.IsPullback → sq.unop.IsPushout | null | true |
NumberField.ComplexEmbedding.IsReal.comp | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {K : Type u_1} [inst : Field K] {k : Type u_2} [inst_1 : Field k] (f : k →+* K) {φ : K →+* ℂ},
NumberField.ComplexEmbedding.IsReal φ → NumberField.ComplexEmbedding.IsReal (φ.comp f) | null | true |
Std.DHashMap.Internal.Raw₀.Const.get!_insertMany_emptyWithCapacity_list_of_mem | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} [EquivBEq α] [LawfulHashable α] {l : List (α × β)}
{k k' : α},
(k == k') = true →
∀ {v : β} [inst_4 : Inhabited β],
List.Pairwise (fun a b => (a.1 == b.1) = false) l →
(k, v) ∈ l →
Std.DHashMap.Internal.Raw₀.Const.get!
... | null | true |
Prod.instCompleteBooleanAlgebra._proof_5 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} {β : Type u_2} [inst : CompleteBooleanAlgebra α] [inst_1 : CompleteBooleanAlgebra β] (a b : α × β),
Lattice.inf a b ≤ a | null | false |
AlternatingMap.map_basis_eq_zero_iff._simp_1 | Mathlib.LinearAlgebra.Determinant | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {ι : Type u_5}
[Finite ι] (e : Module.Basis ι R M) (f : M [⋀^ι]→ₗ[R] R), (f ⇑e = 0) = (f = 0) | null | false |
List.getElem_drop' | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {xs : List α} {i j : ℕ} (h : i + j < xs.length), xs[i + j] = (List.drop i xs)[j] | The `i + j`-th element of a list coincides with the `j`-th element of the list obtained by
dropping the first `i` elements. Version designed to rewrite from the big list to the small list. | true |
Set.vadd_set_range | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : VAdd α β] {ι : Sort u_4} (a : α) (f : ι → β),
a +ᵥ Set.range f = Set.range fun i => a +ᵥ f i | null | true |
Std.IteratorLoop.WithWF.casesOn | Init.Data.Iterators.Consumers.Monadic.Loop | {α : Type w} →
{m : Type w → Type w'} →
{β : Type w} →
[inst : Std.Iterator α m β] →
{γ : Type x} →
{PlausibleForInStep : β → γ → ForInStep γ → Prop} →
{hwf : Std.IteratorLoop.WellFounded α m PlausibleForInStep} →
{motive : Std.IteratorLoop.WithWF α m PlausibleFor... | null | false |
memPartitionSet._sunfold | Mathlib.Data.Set.MemPartition | {α : Type u_1} → (ℕ → Set α) → ℕ → α → Set α | null | false |
_private.Lean.Meta.Sym.ReplaceS.0.Lean.Meta.Sym.visit | Lean.Meta.Sym.ReplaceS | Lean.Expr →
ℕ → (Lean.Expr → ℕ → Lean.Meta.Sym.Internal.AlphaShareBuilderM (Option Lean.Expr)) → Lean.Meta.Sym.M✝ Lean.Expr | null | true |
Std.Internal.List.getValue_of_mem | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {l : List ((_ : α) × β)} {x : (_ : α) × β},
x ∈ l →
∀ {h' : Std.Internal.List.containsKey x.fst l = true},
Std.Internal.List.DistinctKeys l → Std.Internal.List.getValue x.fst l h' = x.snd | null | true |
_private.Mathlib.Combinatorics.Pigeonhole.0.Finset.exists_mem_exists_mem_inf'_card_lt._simp_1_1 | Mathlib.Combinatorics.Pigeonhole | ∀ {ι : Type u_1} {M : Type u_4} {s : Finset ι} [inst : AddCommMonoid M] (b : M), s.card • b = ∑ _x ∈ s, b | null | false |
_private.Mathlib.Algebra.Group.Action.Pointwise.Set.Basic.0.Set.smul_graphOn._simp_1_3 | Mathlib.Algebra.Group.Action.Pointwise.Set.Basic | ∀ {G : Type u_3} [inst : Group G] {a b c : G}, (a = b⁻¹ * c) = (b * a = c) | null | false |
_private.Mathlib.LinearAlgebra.Matrix.Cartan.Realisation.0.CartanMatrix.Realisation.eq_one_or_neg_one_of_eq_zsmul_sRoot._simp_1_1 | Mathlib.LinearAlgebra.Matrix.Cartan.Realisation | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : AddGroup G]
[inst_2 : SubtractionMonoid H] [AddMonoidHomClass F G H] (f : F) (n : ℤ) (g : G), n • f g = f (n • g) | null | false |
Std.TreeMap.contains_minKey? | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [Std.TransCmp cmp] {km : α},
t.minKey? = some km → t.contains km = true | null | true |
TopologicalSpace.Closeds.mem_sInf._simp_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] {S : Set (TopologicalSpace.Closeds α)} {x : α},
(x ∈ sInf S) = ∀ s ∈ S, x ∈ s | null | false |
Seminorm.instAddCommMonoid | Mathlib.Analysis.Normed.Module.Seminorm.Basic | {𝕜 : Type u_3} →
{E : Type u_7} →
[inst : SeminormedRing 𝕜] → [inst_1 : AddGroup E] → [inst_2 : SMul 𝕜 E] → AddCommMonoid (Seminorm 𝕜 E) | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.neg_two_pow_le_toInt_ediv._proof_1_5 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x y : BitVec w},
-2 ^ (w - 1) ≤ x.toInt → x.toInt ≤ x.toInt / y.toInt → ¬-2 ^ (w - 1) ≤ x.toInt / y.toInt → False | null | false |
LocalizedModule.restrictScalars_map_eq | Mathlib.RingTheory.Localization.Module | ∀ {R : Type u_1} [inst : CommSemiring R] (S : Submonoid R) {M : Type u_2} [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] {N : Type u_5} [inst_3 : AddCommMonoid N] [inst_4 : Module R N] {M' : Type u_3} {N' : Type u_4}
[inst_5 : AddCommMonoid M'] [inst_6 : AddCommMonoid N'] [inst_7 : Module R M'] [inst_8 : Module R... | null | true |
CategoryTheory.Functor.IsCoverDense.Types.appIso | Mathlib.CategoryTheory.Sites.DenseSubsite.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{K : CategoryTheory.GrothendieckTopology D} →
{G : CategoryTheory.Functor C D} →
[G.IsCoverDense K] →
[G.IsLocallyFull K] →
... | (Implementation). The maps given in `appIso` is inverse to each other and gives a `ℱ(X) ≅ ℱ'(X)`.
| true |
Finset.sym_nonempty | Mathlib.Data.Finset.Sym | ∀ {α : Type u_1} {s : Finset α} [inst : DecidableEq α] {n : ℕ}, (s.sym n).Nonempty ↔ n = 0 ∨ s.Nonempty | null | true |
List.apply_maxOn_lt_apply_getElem_of_lt_maxIdxOn._proof_2 | Init.Data.List.MinMaxIdx | ∀ {β : Type u_2} {α : Type u_1} [inst : LE β] [inst_1 : DecidableLE β] {f : α → β} {xs : List α} (h : xs ≠ []) {k : ℕ},
k < List.maxIdxOn f xs h → k < xs.length | null | false |
List.not_lex_total._f | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop},
(∀ (x y : α), ¬r x y ∨ ¬r y x) →
∀ (l₁ : List α) (f : List.below (motive := fun l₁ => ∀ (l₂ : List α), ¬List.Lex r l₁ l₂ ∨ ¬List.Lex r l₂ l₁) l₁)
(l₂ : List α), ¬List.Lex r l₁ l₂ ∨ ¬List.Lex r l₂ l₁ | null | false |
USize.sub_def | Init.Data.UInt.Lemmas | ∀ (a b : USize), a - b = { toBitVec := a.toBitVec - b.toBitVec } | null | true |
Lean.Meta.HaveTelescopeInfo.bodyDeps | Lean.Meta.HaveTelescope | Lean.Meta.HaveTelescopeInfo → Std.HashSet ℕ | The set of `have`s that the body depends on, as indices into `haveInfo`.
Used in `computeFixedUsed` to compute used `have`s. | true |
Finset.insert_erase | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a : α}, a ∈ s → insert a (s.erase a) = s | null | true |
TwoSidedIdeal.subtypeMop._proof_1 | Mathlib.RingTheory.TwoSidedIdeal.Operations | ∀ {R : Type u_1} [inst : Ring R] (I : TwoSidedIdeal R) (x x_1 : ↥I),
MulOpposite.op ↑(x + x_1) = MulOpposite.op ↑(x + x_1) | null | false |
Unitization.instModule | Mathlib.Algebra.Algebra.Unitization | {S : Type u_2} →
{R : Type u_3} →
{A : Type u_4} →
[inst : Semiring S] →
[inst_1 : AddCommMonoid R] →
[inst_2 : AddCommMonoid A] → [Module S R] → [Module S A] → Module S (Unitization R A) | null | true |
CategoryTheory.Subfunctor.preimage_eq_top_iff | Mathlib.CategoryTheory.Subfunctor.Image | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F F' : CategoryTheory.Functor C (Type w)}
(G : CategoryTheory.Subfunctor F) (p : F' ⟶ F), G.preimage p = ⊤ ↔ CategoryTheory.Subfunctor.range p ≤ G | null | true |
TensorProduct.LieModule.liftLie_apply | Mathlib.Algebra.Lie.TensorProduct | ∀ (R : Type u) [inst : CommRing R] (L : Type v) (M : Type w) (N : Type w₁) (P : Type w₂) [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]... | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.0._auto_421 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
_private.Mathlib.Algebra.Homology.DerivedCategory.HomologySequence.0.DerivedCategory.shiftMap_homologyFunctor_map_Q._proof_1_1 | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {n : ℤ} (a a' : ℤ), n + a = a' → n + a = a' | null | false |
CategoryTheory.Limits.FormalCoproduct.fromIncl_comp_coproductIsoSelf_inv | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : CategoryTheory.Limits.FormalCoproduct C) (i : X.I),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl i (CategoryTheory.CategoryStruct.id (X.obj i)))
X.coproductIsoSelf.inv =
CategoryTheory.Limits.Sigma.... | null | true |
_private.Mathlib.Topology.Compactness.Lindelof.0.eq_open_union_nat._simp_1_2 | Mathlib.Topology.Compactness.Lindelof | ∀ {α : Type u_1} {ι : Sort u_4} {s : ι → Set α}, (⋃ i, s i = ∅) = ∀ (i : ι), s i = ∅ | null | false |
holderOnWith_singleton._simp_1 | Mathlib.Topology.MetricSpace.Holder | ∀ {X : Type u_1} {Y : Type u_2} [inst : PseudoEMetricSpace X] [inst_1 : PseudoEMetricSpace Y] (C r : NNReal) (f : X → Y)
(x : X), HolderOnWith C r f {x} = True | null | false |
ChartedSpace.secondCountable_of_sigmaCompact | Mathlib.Geometry.Manifold.ChartedSpace | ∀ (H : Type u) (M : Type u_2) [inst : TopologicalSpace H] [inst_1 : TopologicalSpace M] [ChartedSpace H M]
[SecondCountableTopology H] [SigmaCompactSpace M], SecondCountableTopology M | null | true |
List.toFinset_inter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (l l' : List α), (l ∩ l').toFinset = l.toFinset ∩ l'.toFinset | null | true |
CategoryTheory.Functor.mapTriangleOpCompTriangleOpEquivalenceFunctorApp_hom_hom₂ | Mathlib.CategoryTheory.Triangulated.Opposite.Functor | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
(T : CategoryTheory.Pretriangulated.Triangle C),
(... | null | true |
_private.Mathlib.Tactic.Simproc.FinsetInterval.0.Mathlib.Tactic.Simp.Int.Iio_zero | Mathlib.Tactic.Simproc.FinsetInterval | Finset.Iio 0 = ∅ | null | true |
_private.Init.Data.SInt.IntToBitVec.0.ISize.le_iff_toBitVec32_sle._simp_1_1 | Init.Data.SInt.IntToBitVec | ∀ {a b : ISize}, (a ≤ b) = (a.toBitVec.sle b.toBitVec = true) | null | false |
Int8.ofBitVec_le_iff_sle | Init.Data.SInt.Lemmas | ∀ (a b : BitVec 8), Int8.ofBitVec a ≤ Int8.ofBitVec b ↔ a.sle b = true | null | true |
Submodule.finrank_le_one_iff_isPrincipal | Mathlib.LinearAlgebra.Dimension.FreeAndStrongRankCondition | ∀ {K : Type u} {V : Type v} [inst : Ring K] [StrongRankCondition K] [inst_2 : AddCommGroup V] [inst_3 : Module K V]
(W : Submodule K V) [Module.Free K ↥W] [Module.Finite K ↥W], Module.finrank K ↥W ≤ 1 ↔ W.IsPrincipal | null | true |
String.Slice.Pattern.ToBackwardSearcher.ctorIdx | Init.Data.String.Pattern.Basic | {ρ : Type} → {pat : ρ} → {σ : outParam (String.Slice → Type)} → String.Slice.Pattern.ToBackwardSearcher pat σ → ℕ | null | false |
Lean.findInternalDocString? | Lean.DocString.Extension | Lean.Environment → Lean.Name → optParam Bool true → IO (Option (String ⊕ Lean.VersoDocString)) | Finds a docstring without performing any alias resolution or enrichment with extra metadata.
For Markdown docstrings, the result is a string; for Verso docstrings, it's a `VersoDocString`.
Docstrings to be shown to a user should be looked up with `Lean.findDocString?` instead.
| true |
_private.Mathlib.Data.Rat.Cast.Order.0.Mathlib.Meta.Positivity.evalNNRatCast._sparseCasesOn_1 | Mathlib.Data.Rat.Cast.Order | {u : Lean.Level} →
{α : Q(Type u)} →
{zα : Q(Zero «$α»)} →
{e : Q(«$α»)} →
{motive : (a : Option Q(PartialOrder «$α»)) → Mathlib.Meta.Positivity.Strictness zα e a → Sort u} →
{a : Option Q(PartialOrder «$α»)} →
(t : Mathlib.Meta.Positivity.Strictness zα e a) →
({p... | null | false |
AddMonoidHom.comp_apply | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {P : Type u_6} [inst : AddZero M] [inst_1 : AddZero N] [inst_2 : AddZero P] (g : N →+ P)
(f : M →+ N) (x : M), (g.comp f) x = g (f x) | null | true |
_private.Batteries.Data.ByteArray.0.ByteArray.size_set._proof_1 | Batteries.Data.ByteArray | ∀ (a : ByteArray) (i : Fin a.size), ¬↑i < a.size → False | null | false |
FiberwiseLinear.openPartialHomeomorph._proof_8 | Mathlib.Geometry.Manifold.VectorBundle.FiberwiseLinear | ∀ {𝕜 : Type u_3} {B : Type u_2} {F : Type u_1} [inst : TopologicalSpace B] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace 𝕜 F] {U : Set B} (φ : B → F ≃L[𝕜] F),
ContinuousOn (fun x => ↑(φ x).symm) U → ContinuousOn (fun x => (x.1, (φ x.1).symm x.2)) (U ×ˢ Set.univ) | null | false |
Turing.TM2to1.tr | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{Λ : Type u_3} →
{σ : Type u_4} →
[DecidableEq K] →
(Λ → Turing.TM2.Stmt Γ Λ σ) →
Turing.TM2to1.Λ' K Γ Λ σ → Turing.TM1.Stmt (Turing.TM2to1.Γ' K Γ) (Turing.TM2to1.Λ' K Γ Λ σ) σ | The TM2 emulator machine states written as a TM1 program.
This handles the `go` and `ret` states, which shuttle to and from a stack top. | true |
_private.Mathlib.Topology.LocallyClosed.0.isLocallyClosedAt_tfae._simp_1_3 | Mathlib.Topology.LocallyClosed | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Real.summable_nat_rpow_inv._simp_1 | Mathlib.Analysis.PSeries | ∀ {p : ℝ}, (Summable fun n => (↑n ^ p)⁻¹) = (1 < p) | null | false |
SSet.N.opEquiv._proof_4 | Mathlib.AlgebraicTopology.SimplicialSet.NonDegenerateSimplices | ∀ {X : SSet} (y : X.N), SSet.opObjEquiv.symm y.simplex ∈ X.op.nonDegenerate y.dim | null | false |
mul_lt_iff_lt_one_left' | Mathlib.Algebra.Order.Monoid.Unbundled.Basic | ∀ {α : Type u_1} {b : α} [inst : MulOneClass α] [inst_1 : LT α] [MulLeftStrictMono α] [MulLeftReflectLT α] (a : α),
a * b < a ↔ b < 1 | null | true |
Std.DTreeMap.Internal.Impl.getD_insert_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {a : α} {fallback b : β a},
(Std.DTreeMap.Internal.Impl.insert a b t ⋯).impl.getD a fallback = b | null | true |
FreeAddGroup.IsCyclicallyReduced.flatten_replicate | Mathlib.GroupTheory.FreeGroup.CyclicallyReduced | ∀ {α : Type u} {L : List (α × Bool)},
FreeAddGroup.IsCyclicallyReduced L → ∀ (n : ℕ), FreeAddGroup.IsCyclicallyReduced (List.replicate n L).flatten | null | true |
_private.Mathlib.RingTheory.Spectrum.Prime.Topology.0.PrimeSpectrum.compactSpace._simp_1 | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] {ι : Sort u_1} (I : ι → Ideal R),
⋂ i, PrimeSpectrum.zeroLocus ↑(I i) = PrimeSpectrum.zeroLocus ↑(⨆ i, I i) | null | false |
Aesop.instDecidableRelSlotIndexLe._proof_1 | Aesop.Forward.SlotIndex | ∀ (i j : Aesop.SlotIndex), (i.toNat.ble j.toNat).Reflects (i.toNat ≤ j.toNat) | null | false |
_private.Mathlib.Algebra.Central.End.0.LinearEquiv.conjAlgEquiv_ext_iff._simp_1_7 | Mathlib.Algebra.Central.End | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {x : A},
(x ∈ ⊥) = (x ∈ Set.range ⇑(algebraMap R A)) | null | false |
Representation.IndV.hom_ext_iff | Mathlib.RepresentationTheory.Induced | ∀ {k : Type u_1} {G : Type u_2} {H : Type u_3} [inst : CommRing k] [inst_1 : Group G] [inst_2 : Group H] {φ : G →* H}
{A : Type u_4} {B : Type u_5} [inst_3 : AddCommGroup A] [inst_4 : Module k A] {ρ : Representation k G A}
[inst_5 : AddCommGroup B] [inst_6 : Module k B] {f g : Representation.IndV φ ρ →ₗ[k] B},
f ... | null | true |
cantorStep_mem_cantorSet | Mathlib.Topology.Instances.CantorSet | ∀ {x : ℝ}, x ∈ cantorSet → cantorStep x ∈ cantorSet | null | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Append.0.Std.Iter.atIdxSlow?_append_of_productive.match_1_2 | Init.Data.Iterators.Lemmas.Combinators.Append | ∀ {α₁ β : Type u_1} [inst : Std.Iterator α₁ Id β] (it : Std.Iter β) (n : ℕ)
(motive :
(k : ℕ) → Std.Iter.atIdxSlow? k it = none → (∀ j < k, (Std.Iter.atIdxSlow? j it).isSome = true) → k ≤ n.succ → Prop)
(k : ℕ) (hk : Std.Iter.atIdxSlow? k it = none) (hmin : ∀ j < k, (Std.Iter.atIdxSlow? j it).isSome = true)
(... | null | false |
Aesop.GoalStats.casesOn | Aesop.Stats.Basic | {motive : Aesop.GoalStats → Sort u} →
(t : Aesop.GoalStats) →
((goalId : ℕ) →
(goalKind : Aesop.GoalKind) →
(lctxSize depth : ℕ) →
(forwardStateStats : Aesop.ForwardStateStats) →
motive
{ goalId := goalId, goalKind := goalKind, lctxSize := lctxSize, dept... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Log.Basic.0.Real.le_log_one_add_of_nonneg._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Log.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.SimpleGroundValue.casesOn | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Compiler.LCNF.SimpleGroundValue✝ → Sort u} →
(t : Lean.Compiler.LCNF.SimpleGroundValue✝) →
((arg : Lean.Compiler.LCNF.SimpleGroundArg) → motive (Lean.Compiler.LCNF.SimpleGroundValue.arg✝ arg)) →
((val : UInt8) → motive (Lean.Compiler.LCNF.SimpleGroundValue.uint8✝ val)) →
((val : UInt1... | null | false |
real_inner_div_norm_mul_norm_eq_neg_one_of_ne_zero_of_neg_mul | Mathlib.Analysis.InnerProductSpace.Basic | ∀ {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : InnerProductSpace ℝ F] {x : F} {r : ℝ},
x ≠ 0 → r < 0 → inner ℝ x (r • x) / (‖x‖ * ‖r • x‖) = -1 | The inner product of a nonzero vector with a negative multiple of
itself, divided by the product of their norms, has value -1. | true |
_private.Mathlib.Algebra.Group.Units.Defs.0.isUnit_of_mul_isUnit_right.match_1_1 | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {x y : M} (motive : (∃ b, b * (x * y) = 1) → Prop) (x_1 : ∃ b, b * (x * y) = 1),
(∀ (z : M) (hz : z * (x * y) = 1), motive ⋯) → motive x_1 | null | false |
Fin.pred_lt_pred_iff | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n.succ} {ha : a ≠ 0} {hb : b ≠ 0}, a.pred ha < b.pred hb ↔ a < b | null | true |
spinGroup.coe_mul_star_self | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(spinGroup Q)), ↑x * ↑(star x) = 1 | null | true |
ProbabilityTheory.binomial_one_eq_bernoulliMeasure | Mathlib.Probability.Distributions.Binomial | ∀ (p : ↑unitInterval), ProbabilityTheory.binomial 1 p = ProbabilityTheory.bernoulliMeasure 1 0 p | null | true |
Seminorm.sub_mem_ball | Mathlib.Analysis.Normed.Module.Seminorm.Basic | ∀ {𝕜 : Type u_3} {E : Type u_7} [inst : SeminormedRing 𝕜] [inst_1 : AddCommGroup E] [inst_2 : SMul 𝕜 E]
(p : Seminorm 𝕜 E) (x₁ x₂ y : E) (r : ℝ), x₁ - x₂ ∈ p.ball y r ↔ x₁ ∈ p.ball (x₂ + y) r | null | true |
WeierstrassCurve.variableChange_c₄ | Mathlib.AlgebraicGeometry.EllipticCurve.VariableChange | ∀ {R : Type u} [inst : CommRing R] (W : WeierstrassCurve R) (C : WeierstrassCurve.VariableChange R),
(C • W).c₄ = ↑C.u⁻¹ ^ 4 * W.c₄ | null | true |
Matroid.subset_closure._auto_1 | Mathlib.Combinatorics.Matroid.Closure | Lean.Syntax | null | false |
OmegaCompletePartialOrder.«_aux_Mathlib_Order_OmegaCompletePartialOrder___macroRules_OmegaCompletePartialOrder_term_→𝒄__1» | Mathlib.Order.OmegaCompletePartialOrder | Lean.Macro | null | false |
CategoryTheory.Quiv.pathCompositionNaturality | Mathlib.CategoryTheory.Category.Quiv | {C : Type u} →
{D : Type u₁} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₁} D] →
(F : CategoryTheory.Functor C D) →
(CategoryTheory.Cat.freeMap F.toPrefunctor).comp (CategoryTheory.pathComposition D) ≅
(CategoryTheory.pathComposition C)... | Naturality of `pathComposition`. | true |
WithTop.Ioo_coe_top | Mathlib.Order.Interval.Finset.Defs | ∀ (α : Type u_1) [inst : PartialOrder α] [inst_1 : OrderTop α] [inst_2 : LocallyFiniteOrder α] (a : α),
Finset.Ioo ↑a ⊤ = Finset.map Function.Embedding.some (Finset.Ioi a) | null | true |
_private.Lean.Compiler.LCNF.Simp.JpCases.0.Lean.Compiler.LCNF.Simp.extractJpCases.go._f | Lean.Compiler.LCNF.Simp.JpCases | (code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
code.below →
Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) →
Array (Lean.Compiler.LCNF.CodeDecl Lean.Compiler.LCNF.Purity.pure) ×
Lean.Compiler.LCNF.Cases Lean.Compiler.LCNF.Purity.pure | null | false |
Finsupp.single_smul | Mathlib.Data.Finsupp.SMul | ∀ {α : Type u_1} {M : Type u_3} {R : Type u_6} [inst : Zero M] [inst_1 : MonoidWithZero R]
[inst_2 : MulActionWithZero R M] (a b : α) (f : α → M) (r : R), (fun₀ | a => r) b • f a = (fun₀ | a => r • f b) b | null | true |
Mathlib.CrossRef.PiBaseTopic.noConfusion | Mathlib.Tactic.CrossRefAttribute | {P : Sort v✝} → {x y : Mathlib.CrossRef.PiBaseTopic} → x = y → Mathlib.CrossRef.PiBaseTopic.noConfusionType P x y | null | false |
_private.Lean.HeadIndex.0.Lean.Expr.toHeadIndexSlow | Lean.HeadIndex | Lean.Expr → Lean.HeadIndex | Slower version of `toHeadIndexQuick?` that "expands" let-declarations to make
sure we never hit a loose bound variable.
The performance of the `letE` alternative can be improved, but this function should not be in the hotpath
since `toHeadIndexQuick?` succeeds most of the time.
| true |
OrderDual.noMinOrder | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : LT α] [NoMaxOrder α], NoMinOrder αᵒᵈ | null | true |
CategoryTheory.StructuredArrow.ofDiagEquivalence' | Mathlib.CategoryTheory.Comma.Over.Basic | {T : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} T] →
(X : T × T) →
CategoryTheory.StructuredArrow X (CategoryTheory.Functor.diag T) ≌
CategoryTheory.StructuredArrow X.1 (CategoryTheory.Under.forget X.2) | A version of `StructuredArrow.ofDiagEquivalence` with the roles of the first and second
projection swapped. | true |
FirstOrder.Language.Theory.CompleteType.toTheory | Mathlib.ModelTheory.Types | {L : FirstOrder.Language} → {T : L.Theory} → {α : Type w} → T.CompleteType α → (L.withConstants α).Theory | The underlying theory | true |
CentroidHom.instAddCommGroup._proof_4 | Mathlib.Algebra.Ring.CentroidHom | ∀ {α : Type u_1} [inst : NonUnitalNonAssocRing α] (y : CentroidHom α) (x : ℕ), (x • y).toEnd = x • y.toEnd | null | false |
Lean.AttributeExtensionState.newEntries | Lean.Attributes | Lean.AttributeExtensionState → List Lean.AttributeExtensionOLeanEntry | null | true |
Module.Relations.mk | Mathlib.Algebra.Module.Presentation.Basic | {A : Type u} → [inst : Ring A] → (G : Type w₀) → (R : Type w₁) → (R → G →₀ A) → Module.Relations A | null | true |
Lean.ReducibilityStatus.ctorIdx | Lean.ReducibilityAttrs | Lean.ReducibilityStatus → ℕ | null | false |
_private.Lean.Compiler.LCNF.PropagateBorrow.0.Lean.Compiler.LCNF.Decl.applyOwnedness.goCode | Lean.Compiler.LCNF.PropagateBorrow | Std.HashMap Lean.FVarId Lean.Compiler.LCNF.Ownedness →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure) | null | true |
Lean.Meta.RefinedDiscrTree.Key._sizeOf_1 | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | Lean.Meta.RefinedDiscrTree.Key → ℕ | null | false |
ENNReal.tendsto_atTop_zero | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {β : Type u_2} [Nonempty β] [inst : SemilatticeSup β] {f : β → ENNReal},
Filter.Tendsto f Filter.atTop (nhds 0) ↔ ∀ ε > 0, ∃ N, ∀ n ≥ N, f n ≤ ε | null | true |
SheafOfModules.Submodule.instCompleteLattice._proof_7 | Mathlib.Algebra.Category.ModuleCat.Sheaf.Submodule | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} {M : SheafOfModules R} (s : Set M.Submodule), IsGLB s (sInf s) | null | false |
uniqueOfSurjectiveZero | Mathlib.Algebra.Group.Pi.Basic | (α : Type u_4) → {β : Type u_5} → [inst : Zero β] → Function.Surjective 0 → Unique β | If the zero function is surjective, the codomain is trivial. | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.