name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Data.Set.Prod.0.Set.pi_inter_distrib._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t t₁ : (i : ι) → Set (α i)},
(s.pi fun i => t i ∩ t₁ i) = s.pi t ∩ s.pi t₁ | null | false |
_private.Lean.Elab.Tactic.Try.0.Lean.Elab.Tactic.Try.evalSuggestImpl.throwExs | Lean.Elab.Tactic.Try | Lean.TSyntax `tactic → Array Lean.Elab.Tactic.EvalTacticFailure → Lean.Elab.Tactic.Try.TryTacticM (Lean.TSyntax `tactic) | null | true |
sub_lt_comm | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, a - b < c ↔ a - c < b | null | true |
SimpleGraph.Walk.take_add_eq | Mathlib.Combinatorics.SimpleGraph.Walk.Operations | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (p : G.Walk u v) (n m : ℕ),
p.take (n + m) = ((p.take n).append ((p.drop n).take m)).copy ⋯ ⋯ | null | true |
PadicInt.withValIntegersRingEquiv | Mathlib.NumberTheory.Padics.WithVal | {p : ℕ} → [inst : Fact (Nat.Prime p)] → ↥(Valued.integer (Rat.padicValuation p).Completion) ≃+* ℤ_[p] | The `p`-adic integers are ring isomorphic to the integers of the uniform completion
of the rationals at the `p`-adic valuation. | true |
DiscreteTiling.PlacedTile.coe_nonempty_iff | Mathlib.Combinatorics.Tiling.Tile | ∀ {G : Type u_1} {X : Type u_2} {ιₚ : Type u_3} [inst : Group G] [inst_1 : MulAction G X]
{ps : DiscreteTiling.Protoset G X ιₚ} {pt : DiscreteTiling.PlacedTile ps}, (↑pt).Nonempty ↔ (↑(↑ps pt.index)).Nonempty | null | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_signExtend._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, ¬w ≥ v → v - w = 0 → False | null | false |
AddMonoidHom.injective_codRestrict._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f | null | false |
Std.PRange.Least?.recOn | Init.Data.Range.Polymorphic.UpwardEnumerable | {α : Type u} →
{motive : Std.PRange.Least? α → Sort u_1} →
(t : Std.PRange.Least? α) → ((least? : Option α) → motive { least? := least? }) → motive t | null | false |
ContinuousMap.Homotopy.casesOn | Mathlib.Topology.Homotopy.Basic | {X : Type u} →
{Y : Type v} →
[inst : TopologicalSpace X] →
[inst_1 : TopologicalSpace Y] →
{f₀ f₁ : C(X, Y)} →
{motive : f₀.Homotopy f₁ → Sort u_1} →
(t : f₀.Homotopy f₁) →
((toContinuousMap : C(↑unitInterval × X, Y)) →
(map_zero_left : ∀ (x : X... | null | false |
List.any_toArray | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, l.toArray.any p = l.any p | null | true |
_private.Mathlib.Data.Option.NAry.0.Option.map₂_eq_some_iff._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ},
Option.map₂ f a b = some c ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c | null | false |
AddHomClass.toAddHom.eq_1 | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_4} {N : Type u_5} {F : Type u_9} [inst : Add M] [inst_1 : Add N] [inst_2 : FunLike F M N]
[inst_3 : AddHomClass F M N] (f : F), ↑f = { toFun := ⇑f, map_add' := ⋯ } | null | true |
_private.Mathlib.Logic.IsEmpty.Basic.0.leftTotal_iff_isEmpty_left._simp_1_2 | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∃ a, p a) = False | null | false |
CategoryTheory.NatTrans.ext | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F G : CategoryTheory.Functor C D} {x y : CategoryTheory.NatTrans F G}, x.app = y.app → x = y | null | true |
TopologicalSpace.NonemptyCompacts.coe_map | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β}
(hf : Continuous f) (s : TopologicalSpace.NonemptyCompacts α),
↑(TopologicalSpace.NonemptyCompacts.map f hf s) = f '' ↑s | null | true |
_private.Mathlib.Analysis.InnerProductSpace.GramMatrix.0.Matrix.posSemidef_opNorm_smul_gram_sub_gram._proof_1_3 | Mathlib.Analysis.InnerProductSpace.GramMatrix | ∀ {E : Type u_4} {n : Type u_2} {𝕜 : Type u_1} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(v : n → E) (f : E →L[𝕜] F) (c : n →₀ 𝕜),
∑ x ∈ c.support, ∑ x_1 ∈ c.support, (starRingEnd 𝕜) (c ... | null | false |
Ordnode.Bounded.mem_lt | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o : WithBot α} {x : α},
t.Bounded o ↑x → Ordnode.All (fun x_1 => x_1 < x) t | null | true |
TopologicalGroup.IsSES.pushforward._proof_7 | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_3} {B : Type u_4} {C : Type u_1} {E : Type u_2} [inst : Group A] [inst_1 : Group B] [inst_2 : Group C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →* B} {ψ : B →* C}
(H : TopologicalGroup.IsSES φ ψ) [inst_6 : IsTopologicalGroup A] [inst_7 : IsTopolo... | null | false |
Std.PreorderPackage.ofLE._proof_3 | Init.Data.Order.PackageFactories | ∀ (α : Type u_1) (args : Std.Packages.PreorderOfLEArgs α), Std.IsPreorder α | null | false |
_private.Mathlib.Analysis.Convex.Function.0.strictConvexOn_iff_div._simp_1_1 | Mathlib.Analysis.Convex.Function | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : One α] [inst_2 : PartialOrder α] [ZeroLEOneClass α] [NeZero 1],
(0 < 1) = True | null | false |
Subring.mem_mk'._simp_1 | Mathlib.Algebra.Ring.Subring.Defs | ∀ {R : Type u} [inst : NonAssocRing R] {s : Set R} {sm : Submonoid R} (hm : ↑sm = s) {sa : AddSubgroup R} (ha : ↑sa = s)
{x : R}, (x ∈ Subring.mk' s sm sa hm ha) = (x ∈ s) | null | false |
instPartialOrderGroupCone | Mathlib.Algebra.Order.Group.Cone | (G : Type u_1) → [inst : CommGroup G] → PartialOrder (GroupCone G) | null | true |
Lean.Meta.MatcherApp.mk._flat_ctor | Lean.Meta.Match.MatcherApp.Basic | ℕ →
ℕ →
Array Lean.Meta.Match.AltParamInfo →
Option ℕ →
Array Lean.Meta.Match.DiscrInfo →
Lean.Meta.Match.Overlaps →
Lean.Name →
Array Lean.Level →
Array Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.Matche... | null | false |
Real.normedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (a b : ℝ), a + b = b + a | null | false |
Units.liftRight._proof_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (g : M → Nˣ),
(∀ (x : M), ↑(g x) = f x) → g 1 = 1 | null | false |
SSet.RelativeMorphism.Homotopy.h₀._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | Lean.Syntax | null | false |
List.ranges._sunfold | Mathlib.Data.List.Range | List ℕ → List (List ℕ) | null | false |
Turing.PartrecToTM2.contSupp.eq_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.contSupp (Turing.PartrecToTM2.Cont'.comp f k) =
Turing.PartrecToTM2.codeSupp' f k ∪ Turing.PartrecToTM2.contSupp k | null | true |
CategoryTheory.Abelian.SpectralObject.cokernelSequenceCycles_f | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (fg : i ⟶ k)
(h : CategoryTheory.CategoryStruct.comp f g = fg) (n : ... | null | true |
IsLowerSet.null_frontier | Mathlib.MeasureTheory.Order.UpperLower | ∀ {ι : Type u_1} [inst : Fintype ι] {s : Set (ι → ℝ)}, IsLowerSet s → MeasureTheory.volume (frontier s) = 0 | null | true |
_private.Aesop.RuleSet.0.Aesop.BaseRuleSet.merge.match_1 | Aesop.RuleSet | (motive : Option (Aesop.UnorderedArraySet Aesop.RuleName) → Sort u_1) →
(x : Option (Aesop.UnorderedArraySet Aesop.RuleName)) →
(Unit → motive none) → ((ns : Aesop.UnorderedArraySet Aesop.RuleName) → motive (some ns)) → motive x | null | false |
Stream'.WSeq.productive_tail | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s : Stream'.WSeq α) [s.Productive], s.tail.Productive | null | true |
PiLp.norm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖ = ‖b‖ | null | true |
MulEquiv.symmEquiv_apply_apply | Mathlib.Algebra.Group.Equiv.Defs | ∀ (P : Type u_9) (Q : Type u_10) [inst : Mul P] [inst_1 : Mul Q] (h : P ≃* Q) (a : Q),
((MulEquiv.symmEquiv P Q) h) a = h.symm a | null | true |
CategoryTheory.Oplax.OplaxTrans.naturality_comp_assoc | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.OplaxFunctor B C} (self : CategoryTheory.Oplax.OplaxTrans F G) {a b c : B} (f : a ⟶ b)
(g : b ⟶ c) {Z : F.obj a ⟶ G.obj c}
(h : CategoryTheory.CategoryStruct.comp (self.app a) (CategoryT... | null | true |
Matrix.conjTranspose_list_sum | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddMonoid α] [inst_1 : StarAddMonoid α] (l : List (Matrix m n α)),
l.sum.conjTranspose = (List.map Matrix.conjTranspose l).sum | null | true |
SimpleGraph.ConnectedComponent.connected_toSubgraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent), C.toSubgraph.Connected | null | true |
WeierstrassCurve.Jacobian.Point.instAddCommGroup._proof_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (n : ℕ) (a : W.Point),
zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | null | false |
Fin.succ_lt_succ_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, (a.succ < b.succ) = (a < b) | null | false |
Std.TreeMap.Raw.contains_ofList | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (Std.TreeMap.Raw.ofList l cmp).contains k = (List.map Prod.fst l).contains k | null | true |
CategoryTheory.CartesianClosed.curry_id_eq_coev | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A X : C)
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj A ((CategoryTheory.Functor.id C).ob... | **Alias** of `CategoryTheory.MonoidalClosed.curry_id_eq_coev`. | true |
FirstOrder.Language.ElementaryEmbedding.noConfusion | Mathlib.ModelTheory.ElementaryMaps | {P : Sort u} →
{L : FirstOrder.Language} →
{M : Type u_1} →
{N : Type u_2} →
{inst : L.Structure M} →
{inst_1 : L.Structure N} →
{t : L.ElementaryEmbedding M N} →
{L' : FirstOrder.Language} →
{M' : Type u_1} →
{N' : Type u_2} →
... | null | false |
antivaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
AntivaryOn (-f) (-g) s ↔ AntivaryOn f g s | null | true |
MeasureTheory.measureUnivNNReal | Mathlib.MeasureTheory.Measure.Typeclasses.Finite | {α : Type u_1} → {m0 : MeasurableSpace α} → MeasureTheory.Measure α → NNReal | The measure of the whole space with respect to a finite measure, considered as `ℝ≥0`. | true |
Ordnode.splitMax | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Option (Ordnode α × α) | O(log n). Extract and remove the maximum element from the tree, if it exists.
```
split_max {1, 2, 3} = some ({1, 2}, 3)
split_max ∅ = none
``` | true |
CategoryTheory.Comma.leftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L₁ : CategoryTheory.Functor A T} →
{R₁ : CategoryTheory.Functor B T} → {X... | Extract the isomorphism between the left objects from an isomorphism in the comma category. | true |
isPRadical_iff | Mathlib.FieldTheory.IsPerfectClosure | ∀ {K : Type u_1} {L : Type u_2} [inst : CommSemiring K] [inst_1 : CommSemiring L] (i : K →+* L) (p : ℕ),
IsPRadical i p ↔ (∀ (x : L), ∃ n y, i y = x ^ p ^ n) ∧ RingHom.ker i ≤ pNilradical K p | null | true |
BoundingSieve.selbergTerms | Mathlib.NumberTheory.SelbergSieve | {s : BoundingSieve} → ArithmeticFunction ℝ | These are the terms that appear in the sum `S` in the main term of the fundamental theorem.
$$S = \sum_{l \mid P, l \le \sqrt{y}} g(l)$$ | true |
Matroid.ext_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M M' : Matroid α}, M.E = M'.E → (∀ S ⊆ M.E, M.Spanning S ↔ M'.Spanning S) → M = M' | null | true |
Nat.Linear.PolyCnstr.mk | Init.Data.Nat.Linear | Bool → Nat.Linear.Poly → Nat.Linear.Poly → Nat.Linear.PolyCnstr | null | true |
_private.Std.Time.Format.Basic.0.Std.Time.instReprFormatPart.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.FormatPart → Sort u_1) →
(x : Std.Time.FormatPart) →
((a : String) → motive (Std.Time.FormatPart.string a)) →
((a : Std.Time.Modifier) → motive (Std.Time.FormatPart.modifier a)) → motive x | null | false |
Filter.Tendsto.nonpos_add_atBot | Mathlib.Order.Filter.AtTopBot.Monoid | ∀ {α : Type u_1} {M : Type u_2} [inst : AddCommMonoid M] [inst_1 : Preorder M] [IsOrderedAddMonoid M] {l : Filter α}
{f g : α → M},
(∀ (x : α), f x ≤ 0) → Filter.Tendsto g l Filter.atBot → Filter.Tendsto (fun x => f x + g x) l Filter.atBot | null | true |
MeasureTheory.eLpNorm_conj | Mathlib.MeasureTheory.Function.LpSeminorm.Monotonicity | ∀ {α : Type u_1} {m : MeasurableSpace α} {𝕜 : Type u_5} [inst : RCLike 𝕜] (f : α → 𝕜) (p : ENNReal)
(μ : MeasureTheory.Measure α), MeasureTheory.eLpNorm ((starRingEnd (α → 𝕜)) f) p μ = MeasureTheory.eLpNorm f p μ | null | true |
Function.locallyFinsuppWithin.instMaxOfSemilatticeSup | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} → {Y : Type u_2} → [SemilatticeSup Y] → [inst_2 : Zero Y] → Max (Function.locallyFinsuppWithin U Y) | null | true |
WithCStarModule.inner_single_right | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [inst_7 : StarOrderedRing A]... | null | true |
Aesop.MVarClusterData.goals | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp → Array (IO.Ref Goal) | null | true |
ProofWidgets.CheckRequestResponse.noConfusion | ProofWidgets.Cancellable | {P : Sort u} →
{t t' : ProofWidgets.CheckRequestResponse} → t = t' → ProofWidgets.CheckRequestResponse.noConfusionType P t t' | null | false |
_private.Init.Data.Vector.Basic.0.Vector.mapM.go._unary._proof_4 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k < n, k + 1 ≤ n | null | false |
_private.Lean.Server.Completion.CompletionItemCompression.0.Lean.Lsp.ResolvableCompletionList.compressEditFast | Lean.Server.Completion.CompletionItemCompression | String → Lean.Lsp.InsertReplaceEdit → String | null | true |
String.Pos.toSlice_nextn | Init.Data.String.Lemmas.Basic | ∀ {n : ℕ} {s : String} {p : s.Pos}, (p.nextn n).toSlice = p.toSlice.nextn n | null | true |
_private.Mathlib.RingTheory.SimpleModule.Isotypic.0.Submodule.le_linearEquiv_of_sSup_eq_top.match_1_3 | Mathlib.RingTheory.SimpleModule.Isotypic | ∀ {R : Type u_2} {M : Type u_1} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (N : Submodule R M)
(s : Set (Submodule R M)) (w : Submodule R M) (compl : IsCompl N w)
(motive : (∃ m ∈ s, N.projectionOnto w compl ∘ₗ m.subtype ≠ 0) → Prop)
(x : ∃ m ∈ s, N.projectionOnto w compl ∘ₗ m.subtype ≠ 0),
... | null | false |
IsNilpotent.charpoly_eq_X_pow_finrank | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [IsDomain R] [inst_2 : AddCommGroup M] [inst_3 : Module R M]
[inst_4 : Module.Finite R M] [inst_5 : Module.Free R M] {φ : Module.End R M},
IsNilpotent φ → LinearMap.charpoly φ = Polynomial.X ^ Module.finrank R M | null | true |
Lean.Meta.DefEqCacheKind.toCtorIdx | Lean.Meta.ExprDefEq | Lean.Meta.DefEqCacheKind → ℕ | null | false |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.fundCircuit_eq_sInter._simp_1_2 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | null | false |
ULift.mul | Mathlib.Algebra.Group.ULift | {α : Type u} → [Mul α] → Mul (ULift.{u_1, u} α) | null | true |
Std.TreeSet.get?_erase | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k a : α},
(t.erase k).get? a = if cmp k a = Ordering.eq then none else t.get? a | null | true |
Std.Internal.IndexMultiMap.getAll? | Std.Http.Internal.IndexMultiMap | {α : Type u} →
{β : Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.Internal.IndexMultiMap α β → α → Option (Array β) | Retrieves all values for the given key, or `none` if the key is absent.
| true |
LowerSemicontinuousWithinAt.le_liminf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {x : α} {γ : Type u_4} [inst_1 : CompleteLinearOrder γ]
{f : α → γ}, LowerSemicontinuousWithinAt f s x → f x ≤ Filter.liminf f (nhdsWithin x s) | **Alias** of the forward direction of `lowerSemicontinuousWithinAt_iff_le_liminf`. | true |
Int.Nonneg.mul | Init.Data.Int.OfNat | ∀ (a b : ℤ), a ≥ 0 → b ≥ 0 → a * b ≥ 0 | null | true |
Subsemiring.instCompleteLattice._proof_2 | Mathlib.Algebra.Ring.Subsemiring.Basic | ∀ {R : Type u_1} [inst : NonAssocSemiring R] (x x_1 : Subsemiring R) (x_2 : R), x_2 ∈ ↑x ∧ x_2 ∈ ↑x_1 → x_2 ∈ ↑x | null | false |
BitVec.toInt_neg_of_msb_true | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, x.msb = true → x.toInt < 0 | null | true |
CategoryTheory.Limits.HasZeroObject.instMono | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C] {X : C}
(f : 0 ⟶ X), CategoryTheory.Mono f | null | true |
Qq.getLevelQ | Mathlib.Util.Qq | Lean.Expr → Lean.MetaM ((u : Lean.Level) × Q(Sort u)) | If `e` has type `Sort u` for some level `u`, return `u` and `e : Q(Sort u)`. | true |
Finset.Ico_subset_Iio_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Iio b | null | true |
measurable_to_countable' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [Countable α] [inst_2 : MeasurableSpace β] {f : β → α},
(∀ (x : α), MeasurableSet (f ⁻¹' {x})) → Measurable f | null | true |
_private.Mathlib.RingTheory.Jacobson.Ideal.0.Ideal.jacobson_eq_top_iff.match_1_3 | Mathlib.RingTheory.Jacobson.Ideal | ∀ {R : Type u_1} [inst : Ring R] {I : Ideal R} (x : Ideal R) (motive : x ∈ {J | I ≤ J ∧ J.IsMaximal} → Prop)
(x_1 : x ∈ {J | I ≤ J ∧ J.IsMaximal}), (∀ (hij : I ≤ x) (right : x.IsMaximal), motive ⋯) → motive x_1 | null | false |
«_aux_Mathlib_NumberTheory_Padics_Complex___macroRules_term𝓞_ℂ_[_]_1» | Mathlib.NumberTheory.Padics.Complex | Lean.Macro | null | false |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_13 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (c : C)
{c' c'' : C} (f : c' ⟶ c'') (d : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f) d =
CategoryTheory.CategoryStruct.comp (CategoryTheo... | null | false |
CancelCommMonoidWithZero.mk.sizeOf_spec | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [inst : SizeOf M₀] (toCommMonoidWithZero : CommMonoidWithZero M₀)
(toIsLeftCancelMulZero : IsLeftCancelMulZero M₀),
sizeOf { toCommMonoidWithZero := toCommMonoidWithZero, toIsLeftCancelMulZero := toIsLeftCancelMulZero } =
1 + sizeOf toCommMonoidWithZero + sizeOf toIsLeftCancelMulZero | null | true |
lipschitzOnWith_iff_norm_inv_mul_le | Mathlib.Analysis.Normed.Group.Uniform | ∀ {E : Type u_2} {F : Type u_3} [inst : SeminormedGroup E] [inst_1 : SeminormedGroup F] {s : Set E} {f : E → F}
{C : NNReal}, LipschitzOnWith C f s ↔ ∀ ⦃x : E⦄, x ∈ s → ∀ ⦃y : E⦄, y ∈ s → ‖(f x)⁻¹ * f y‖ ≤ ↑C * ‖x⁻¹ * y‖ | null | true |
BitVec.umulOverflow.eq_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x y : BitVec w), x.umulOverflow y = decide (x.toNat * y.toNat ≥ 2 ^ w) | null | true |
_private.Mathlib.Data.List.Nodup.0.List.nodup_iff_count_eq_one._proof_1_4 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} {l : List α} [inst : BEq α] (x : α),
(List.count x l ≤ 1) = ¬(1 ≤ List.count x l → List.count x l = 1) →
List.count x l ≤ 1 → 0 < (List.filter (fun x_1 => x_1 == x) l).length | null | false |
_private.Mathlib.RingTheory.HahnSeries.Basic.0.HahnSeries.ofIterate._simp_3 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {s : Set β} {a : α}, (a ∈ f ⁻¹' s) = (f a ∈ s) | null | false |
InnerProductGeometry.norm_add_eq_norm_sub_iff_angle_eq_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Unoriented.Basic | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] (x y : V),
‖x + y‖ = ‖x - y‖ ↔ InnerProductGeometry.angle x y = Real.pi / 2 | The norm of the sum of two vectors equals the norm of their difference if and only if
the angle between them is π/2. | true |
CategoryTheory.ShortComplex.leftHomologyIso_hom_naturality_assoc | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] (φ : S₁ ⟶ S₂) {Z : C}
(h : S₂.homology ⟶ Z),
CategoryTheory.CategoryStruct.comp S₁.leftHomologyIso.hom
(Cat... | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0.Nat.NatOffset.ctorElim | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | {motive : Nat.NatOffset✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Nat.NatOffset✝) → ctorIdx = Nat.NatOffset.ctorIdx✝ t → Nat.NatOffset.ctorElimType✝ ctorIdx → motive t | null | false |
CategoryTheory.Equivalence.counitInv_app_tensor_comp_functor_map_δ_inverse_assoc | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {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] (e : C ≌ D)
[inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal] (X Y : C) {Z : D}
... | null | true |
Lean.Meta.FindSplitImpl.Context.mk | Lean.Meta.Tactic.SplitIf | Lean.ExprSet → Lean.Meta.SplitKind → Lean.Meta.FindSplitImpl.Context | null | true |
Multiset.card_eq_countP_add_countP | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] (s : Multiset α),
s.card = Multiset.countP p s + Multiset.countP (fun x => ¬p x) s | null | true |
Nat.and_left_comm | Batteries.Data.Nat.Bitwise.Lemmas | ∀ (x y z : ℕ), x &&& (y &&& z) = y &&& (x &&& z) | null | true |
_private.Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue.0.MeasureTheory.Measure.add_sub_of_mutuallySingular._abel_1_1 | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν ξ : MeasureTheory.Measure α} (h : μ.MutuallySingular ξ),
μ.restrict h.nullSet + μ.restrict h.nullSetᶜ + (ν - ξ).restrict h.nullSet + (ν - ξ).restrict h.nullSetᶜ =
μ.restrict h.nullSet + (ν - ξ).restrict h.nullSet + (μ.restrict h.nullSetᶜ + (ν - ξ).restrict h.nullSetᶜ) | null | false |
Std.DTreeMap.Raw.min?_keys | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Min α] [inst_1 : LE α] [Std.LawfulOrderCmp cmp] [Std.LawfulOrderMin α] [Std.LawfulOrderLeftLeaningMin α]
[Std.LawfulEqCmp cmp], t.WF → t.keys.min? = t.minKey? | null | true |
UpperSet.instAddCommMonoid._proof_1 | Mathlib.Algebra.Order.UpperLower | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : Preorder α] [inst_2 : IsOrderedAddMonoid α] (a b : UpperSet α),
a + b = b + a | null | false |
String.Slice.sliceTo_eq_self_iff | Init.Data.String.Lemmas.Basic | ∀ {s : String.Slice} {p : s.Pos}, s.sliceTo p = s ↔ p = s.endPos | null | true |
Substring.Raw.Valid.next_stop | Batteries.Data.String.Lemmas | ∀ {s : Substring.Raw}, s.Valid → s.next { byteIdx := s.bsize } = { byteIdx := s.bsize } | null | true |
_private.Mathlib.Topology.UniformSpace.Closeds.0.UniformSpace.hausdorff.uniformContinuous_prod.match_1_1 | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β] (U : Set (α × α)) (V : Set (β × β))
(motive : (U, V).1 ∈ uniformity α ∧ (U, V).2 ∈ uniformity β → Prop)
(x : (U, V).1 ∈ uniformity α ∧ (U, V).2 ∈ uniformity β),
(∀ (hU : (U, V).1 ∈ uniformity α) (hV : (U, V).2 ∈ uniformity β), motiv... | null | false |
IntermediateField.subsingleton_of_rank_adjoin_eq_one | Mathlib.FieldTheory.IntermediateField.Adjoin.Basic | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E],
(∀ (x : E), Module.rank F ↥F⟮x⟯ = 1) → Subsingleton (IntermediateField F E) | null | true |
_private.Init.Meta.0.Lean.Parser.Tactic._aux_Init_Meta___macroRules_Lean_Parser_Tactic_declareSimpLikeTactic_1.match_4 | Init.Meta | (motive : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command → Sort u_1) →
(x : Lean.TSyntax `term × Lean.TSyntax `term × Lean.TSyntax `command) →
((kind tkn : Lean.TSyntax `term) → (stx : Lean.TSyntax `command) → motive (kind, tkn, stx)) → motive x | null | false |
CategoryTheory.Functor.IsIso.mk._flat_ctor | Mathlib.CategoryTheory.IsoCat | ∀ {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] {F : CategoryTheory.Functor C D},
autoParam F.Faithful CategoryTheory.Functor.IsIso.faithful._autoParam →
autoParam F.Full CategoryTheory.Functor.IsIso.full._autoParam → Function.Bijecti... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.