name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Meta.instDecidableEqProjReductionKind._proof_1 | Lean.Meta.Basic | ∀ (x y : Lean.Meta.ProjReductionKind), x.ctorIdx = y.ctorIdx → x = y | null | false |
WeaklyLawfulMonadAttach.casesOn | Init.Control.MonadAttach | {m : Type u → Type v} →
[inst : Monad m] →
[inst_1 : MonadAttach m] →
{motive : WeaklyLawfulMonadAttach m → Sort u_1} →
(t : WeaklyLawfulMonadAttach m) →
((map_attach : ∀ {α : Type u} {x : m α}, Subtype.val <$> MonadAttach.attach x = x) → motive ⋯) → motive t | null | false |
Cardinal.nat_le_lift_iff._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {n : ℕ} {a : Cardinal.{u}}, (↑n ≤ Cardinal.lift.{v, u} a) = (↑n ≤ a) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.cpop_cons._simp_1_1 | Init.Data.BitVec.Lemmas | ∀ (n : ℕ), (n < n + 1) = True | null | false |
Valuation.instCommGroupWithZeroSubtypeMemSubmonoidMrangeMonoidWithZeroHomOfClass._proof_9 | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_2} {Γ₀ : Type u_1} [inst : LinearOrderedCommGroupWithZero Γ₀] [inst_1 : DivisionRing K]
(v : Valuation K Γ₀), 0⁻¹ = 0 | null | false |
MvPFunctor.WPath._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.W) → (a_1 : Fin2 n) → SizeOf (P.WPath a a_1) | null | false |
Plausible.Gen.chooseNat | Plausible.Gen | Plausible.Gen ℕ | Choose a `Nat` between `0` and `getSize`.
| true |
Lean.Meta.Grind.Arith.Linear.pp? | Lean.Meta.Tactic.Grind.Arith.Linear.PP | Lean.Meta.Grind.Goal → Lean.MetaM (Option Lean.MessageData) | null | true |
CategoryTheory.Pi.laxMonoidalPi._proof_10 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_5}
[inst_2 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → Cate... | null | false |
EuclideanGeometry.Sphere.IsDiameter.midpoint_eq_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → midpoint ℝ p₁ p₂ = s.center | null | true |
CategoryTheory.ComposableArrows.Precomp.map.congr_simp | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n) {X : C}
(f f_1 : X ⟶ F.left),
f = f_1 →
∀ (i j : Fin (n + 1 + 1)) (x : i ≤ j),
CategoryTheory.ComposableArrows.Precomp.map F f i j x = CategoryTheory.ComposableArrows.Precomp.map F f_1 i j x | null | true |
Set.empty_disjoint._simp_1 | Mathlib.Data.Set.Disjoint | ∀ {α : Type u} (s : Set α), Disjoint ∅ s = True | null | false |
Dilation.ratio_comp' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β},
(∃ x y, edist x y ≠ 0 ∧ edist x y ≠ ⊤) → Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f | Ratio of the composition `g.comp f` of two dilations is the product of their ratios. We assume
that there exist two points in `α` at extended distance neither `0` nor `∞` because otherwise
`Dilation.ratio (g.comp f) = Dilation.ratio f = 1` while `Dilation.ratio g` can be any number. This
version works for most general ... | true |
Nat.count_le_cardinal | Mathlib.SetTheory.Cardinal.NatCount | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (n : ℕ), ↑(Nat.count p n) ≤ Cardinal.mk ↑{k | p k} | null | true |
Aesop.GoalUnsafe.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.GoalUnsafe} → t = t' → Aesop.GoalUnsafe.noConfusionType P t t' | null | false |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.initFn.match_1._@.Mathlib.Tactic.CategoryTheory.Elementwise.3754623819._hygCtx._hyg.2 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Option (Lean.Level × Lean.Level) → Sort u_1) →
(level? : Option (Lean.Level × Lean.Level)) →
((levelW levelUF : Lean.Level) → motive (some (levelW, levelUF))) →
((x : Option (Lean.Level × Lean.Level)) → motive x) → motive level? | null | false |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.evalGrindTraceCore.match_3 | Lean.Elab.Tactic.Grind.Main | (motive : Lean.Meta.Grind.ActionResult → Sort u_1) →
(__do_lift : Lean.Meta.Grind.ActionResult) →
((seq : List Lean.Meta.Grind.TGrind) → motive (Lean.Meta.Grind.ActionResult.closed seq)) →
((gs : List Lean.Meta.Grind.Goal) → motive (Lean.Meta.Grind.ActionResult.stuck gs)) → motive __do_lift | null | false |
ProofWidgets.Jsx.delabHtmlOfComponent' | ProofWidgets.Data.Html | Lean.PrettyPrinter.Delaborator.DelabM (Lean.TSyntax `proofWidgetsJsxElement) | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.DefEqM.Context._sizeOf_1 | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.DefEqM.Context✝ → ℕ | null | false |
Group.rootableByNatOfRootableByInt.eq_1 | Mathlib.GroupTheory.Divisible | ∀ (A : Type u_1) [inst : Group A] [inst_1 : RootableBy A ℤ],
Group.rootableByNatOfRootableByInt A = { root := fun a n => RootableBy.root a ↑n, root_zero := ⋯, root_cancel := ⋯ } | null | true |
Rat.zero_add | Init.Data.Rat.Lemmas | ∀ (a : ℚ), 0 + a = a | null | true |
_private.Mathlib.AlgebraicGeometry.Cover.Open.0.AlgebraicGeometry.Scheme.OpenCover.ext_elem._simp_1_2 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
uniform_continuous_npow_on_bounded | Mathlib.Algebra.Order.Field.Basic | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] (B : α) {ε : α},
0 < ε → ∀ (n : ℕ), ∃ δ > 0, ∀ (q r : α), |r| ≤ B → |q - r| ≤ δ → |q ^ n - r ^ n| < ε | null | true |
Std.DHashMap.Internal.Raw₀.contains_diff_eq_false_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, m₁.contains k = false → (m₁.diff m₂).contains k = false | null | true |
EuclideanGeometry.image_inversion_sphere_dist_center | Mathlib.Geometry.Euclidean.Inversion.ImageHyperplane | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {c y : P} {R : ℝ},
R ≠ 0 →
y ≠ c →
EuclideanGeometry.inversion c R '' Metric.sphere y (dist y c) =
insert c ↑(AffineSubspace.perpBisector c (Euclid... | null | true |
SpecialLinearGroup.instGroup._proof_10 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V]
(a : SpecialLinearGroup R V), a⁻¹ * a = 1 | null | false |
_private.Mathlib.CategoryTheory.Presentable.OrthogonalReflection.0.CategoryTheory.OrthogonalReflection.toSucc_surjectivity._simp_1_1 | Mathlib.CategoryTheory.Presentable.OrthogonalReflection | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {W : CategoryTheory.MorphismProperty C} {Z : C}
[inst_1 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₁]
[inst_2 : CategoryTheory.Limits.HasCoproduct CategoryTheory.OrthogonalReflection.D₁.obj₂] {X Y : C} (f : X ⟶ Y)
(hf : W... | null | false |
UniformConcaveOn | Mathlib.Analysis.Convex.Strong | {E : Type u_1} → [inst : NormedAddCommGroup E] → [NormedSpace ℝ E] → Set E → (ℝ → ℝ) → (E → ℝ) → Prop | A function `f` from a real normed space is uniformly concave with modulus `φ` if
`t • f x + (1 - t) • f y + t * (1 - t) * φ ‖x - y‖ ≤ f (t • x + (1 - t) • y)` for all `t ∈ [0, 1]`.
`φ` is usually taken to be a monotone function such that `φ r = 0 ↔ r = 0`. | true |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData._proof_7 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H ... | null | false |
Std.Do.PostShape.pure.sizeOf_spec | Std.Do.PostCond | sizeOf Std.Do.PostShape.pure = 1 | null | true |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.preimage_mul_const_Icc_of_neg._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = Set.Ici a ∩ Set.Iic b | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Semisimple.0.LinearMap.IsSymmetric.isFinitelySemisimple._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Semisimple | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_preΨ'_pos._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {a b : ℕ}, (0 < a / b) = (0 < b ∧ b ≤ a) | null | false |
CategoryTheory.GrothendieckTopology.Point | Mathlib.CategoryTheory.Sites.Point.Basic | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → CategoryTheory.GrothendieckTopology C → Type (max (max u v) (w + 1)) | Given `J` a Grothendieck topology on a category `C`, a point of the site `(C, J)`
consists of a functor `fiber : C ⥤ Type w` such that the category `fiber.Elements`
is initially small (which allows defining the fiber functor on presheaves by
taking colimits) and cofiltered (so that the fiber functor on presheaves is ex... | true |
CategoryTheory.Limits.colimitHomIsoLimitYoneda._proof_1 | Mathlib.CategoryTheory.Limits.IndYoneda | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {I : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} I] (F : CategoryTheory.Functor I C) [CategoryTheory.Limits.HasColimit F]
(A : C), CategoryTheory.Limits.HasLimit (F.op.comp (CategoryTheory.yoneda.obj A)) | null | false |
Subalgebra.equivOfEq._proof_4 | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S T : Subalgebra R A), S = T → ∀ (x : ↥T), ↑x ∈ S | null | false |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkEqTrans?.match_1 | Lean.Meta.AppBuilder | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(h₁? h₂? : Option Lean.Expr) →
(Unit → motive none none) →
((h : Lean.Expr) → motive none (some h)) →
((h : Lean.Expr) → motive (some h) none) → ((h₁ h₂ : Lean.Expr) → motive (some h₁) (some h₂)) → motive h₁? h₂? | null | false |
Lean.Lsp.instToJsonInitializeResult | Lean.Data.Lsp.InitShutdown | Lean.ToJson Lean.Lsp.InitializeResult | null | true |
Std.ExtTreeMap.getD_ofList_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v fallback : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → (Std.ExtTreeMap.ofList l cmp).getD k' fallback = v | null | true |
Std.ExtTreeMap.getElem!_eq_default | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited β] {a : α}, a ∉ t → t[a]! = default | null | true |
Manifold.IsSubmersion.prodMap | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_1} {E' : Type u_2} {E'' : Type u_3} {E''' : Type u_4} {H : Type u_7} {H' : Type u_8} {G : Type u_9}
{G' : Type u_10} {E : Type u} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
[inst_5 : N... | If `f: M → N` and `g: M' × N'` are submersions at `x` and `x'`, respectively,
then `f × g: M × N → M' × N'` is a submersion at `(x, x')`. | true |
Lean.Grind.Linarith.Expr.collectVars | Lean.Meta.Tactic.Grind.Arith.Linear.VarRename | Lean.Grind.Linarith.Expr → Lean.Meta.Grind.VarCollector | null | true |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently₂._simp_1_2 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (f '' s ∩ t).Nonempty = (s ∩ f ⁻¹' t).Nonempty | null | false |
_private.Lean.Meta.InferType.0.Lean.Meta.isPropQuickApp._unsafe_rec | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool | null | false |
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusion | Mathlib.Tactic.Widget.SelectPanelUtils | {P : Sort u} →
{t t' : RpcEncodablePacket✝} →
t = t' →
RpcEncodablePacket.«_@».Mathlib.Tactic.Widget.SelectPanelUtils.2749655504._hygCtx._hyg.1.noConfusionType P t t' | null | false |
ENat.toENNReal_ne_top._simp_1 | Mathlib.Data.Real.ENatENNReal | ∀ {n : ℕ∞}, (↑n ≠ ⊤) = (n ≠ ⊤) | null | false |
Lean.Meta.Sym.Internal.mkAppS₈ | Lean.Meta.Sym.AlphaShareBuilder | {m : Type → Type} →
[Lean.Meta.Sym.Internal.MonadShareCommon m] →
[Monad m] →
Lean.Expr →
Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → m Lean.Expr | null | true |
_private.Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex.0.SSet.stdSimplex.bijective_image_objEquiv_toOrderHom_univ._simp_1_2 | Mathlib.AlgebraicTopology.SimplicialSet.StdSimplex | ∀ {n m : SimplexCategory} {f : n ⟶ m}, CategoryTheory.Mono f = Function.Injective ⇑(SimplexCategory.Hom.toOrderHom f) | null | false |
_private.Lean.Elab.Tactic.BVDecide.LRAT.Trim.0.Lean.Elab.Tactic.BVDecide.LRAT.trim.useAnalysis.go.match_1 | Lean.Elab.Tactic.BVDecide.LRAT.Trim | (motive : Option Std.Tactic.BVDecide.LRAT.IntAction → Sort u_1) →
(step? : Option Std.Tactic.BVDecide.LRAT.IntAction) →
((step : Std.Tactic.BVDecide.LRAT.IntAction) → motive (some step)) → (Unit → motive none) → motive step? | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.all.eq_1 | Init.Data.String.Lemmas.Pattern.Char | ∀ {ρ : Type} (s : String.Slice) (pat : ρ) [inst : String.Slice.Pattern.ForwardPattern pat],
s.all pat = (s.skipPrefixWhile pat == s.endPos) | null | true |
IntermediateField.adjoinRootEquivAdjoin._proof_1 | 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] {α : E},
IsIntegral F α →
Function.Bijective
⇑(AdjoinRoot.liftAlgHom (minpoly F α) (Algebra.ofId F ↥F⟮α⟯) (IntermediateField.AdjoinSimple.gen F α) ⋯) | null | false |
Aesop.Goal.instBEq | Aesop.Tree.Data | BEq Aesop.Goal | null | true |
Stream'.append_append_stream | Mathlib.Data.Stream.Init | ∀ {α : Type u} (l₁ l₂ : List α) (s : Stream' α), l₁ ++ l₂ ++ₛ s = l₁ ++ₛ (l₂ ++ₛ s) | null | true |
Matroid.loopless_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} (M : Matroid α), M.Loopless ↔ M.loops = ∅ | null | true |
Nat.nth._proof_1 | Mathlib.Data.Nat.Nth | ∀ (p : ℕ → Prop), ¬(setOf p).Finite → Infinite ↑(setOf p) | null | false |
AddCommMonCat.instConcreteCategoryAddMonoidHomCarrier._proof_3 | Mathlib.Algebra.Category.MonCat.Basic | ∀ {X : AddCommMonCat} (x : ↑X), (CategoryTheory.CategoryStruct.id X).hom' x = x | null | false |
FirstOrder.Language.BoundedFormula.sumElim_comp_relabelAux | Mathlib.ModelTheory.Syntax | ∀ {M : Type w} {α : Type u'} {β : Type v'} {n m : ℕ} {g : α → β ⊕ Fin n} {v : β → M} {xs : Fin (n + m) → M},
Sum.elim v xs ∘ FirstOrder.Language.BoundedFormula.relabelAux g m =
Sum.elim (Sum.elim v (xs ∘ Fin.castAdd m) ∘ g) (xs ∘ Fin.natAdd n) | null | true |
_private.Init.System.FilePath.0.System.instHashableFilePath.hash.match_1 | Init.System.FilePath | (motive : System.FilePath → Sort u_1) → (x : System.FilePath) → ((a : String) → motive { toString := a }) → motive x | null | false |
ArithmeticFunction.carmichael_finset_prod | Mathlib.NumberTheory.ArithmeticFunction.Carmichael | ∀ {α : Type u_2} {s : Finset α} {f : α → ℕ},
(↑s).Pairwise (Function.onFun Nat.Coprime f) →
ArithmeticFunction.carmichael (s.prod f) = s.lcm (⇑ArithmeticFunction.carmichael ∘ f) | **Alias** of `ArithmeticFunction.carmichael_finsetProd`. | true |
Finset.inf'._proof_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] (s : Finset β),
s.Nonempty → ∀ (f : β → α), s.inf (WithTop.some ∘ f) ≠ ⊤ | null | false |
_private.Lean.Compiler.Specialize.0.Lean.Compiler.specializeAttr._regBuiltin.Lean.Compiler.specializeAttr.docString_1 | Lean.Compiler.Specialize | IO Unit | null | false |
Filter.div_mem_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s / t ∈ f / g | null | true |
ContinuousLinearMapWOT.delabOfCLM | Mathlib.Analysis.LocallyConvex.WeakOperatorTopology | Lean.PrettyPrinter.Delaborator.Delab | This prevents `ofCLM A` being printed as `{ toCLM := x }` by `delabStructureInstance`. | true |
Array.foldl_cons_eq_append | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {stop : ℕ} {as : Array α} {bs : List β} {f : α → β},
stop = as.size → Array.foldl (fun acc a => f a :: acc) bs as 0 stop = (Array.map f as).reverse.toList ++ bs | null | true |
ContinuousMultilinearMap.isUniformEmbedding_toUniformOnFun | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ {𝕜 : Type u_1} {ι : Type u_2} {E : ι → Type u_3} {F : Type u_4} [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F] [inst_6 : UniformSpace F]
[inst_7 : IsUniformAddGroup... | null | true |
Ctop.Realizer.is_basis | Mathlib.Data.Analysis.Topology | ∀ {α : Type u_1} [T : TopologicalSpace α] (F : Ctop.Realizer α), TopologicalSpace.IsTopologicalBasis (Set.range F.F.f) | null | true |
Lean.FuzzyMatching.CharType.separator.elim | Lean.Data.FuzzyMatching | {motive : Lean.FuzzyMatching.CharType → Sort u} →
(t : Lean.FuzzyMatching.CharType) → t.ctorIdx = 2 → motive Lean.FuzzyMatching.CharType.separator → motive t | null | false |
_private.Std.Data.DTreeMap.Internal.WF.Lemmas.0.Std.DTreeMap.Internal.Impl.link2.match_1.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u_1} {β : α → Type u_2} (l l'' : Std.DTreeMap.Internal.Impl α β)
(motive : Std.DTreeMap.Internal.Impl.Tree α β (l.size + l''.size) → Sort u_3) (ℓ : Std.DTreeMap.Internal.Impl α β)
(hℓ₁ : ℓ.Balanced) (hℓ₂ : ℓ.size = l.size + l''.size)
(h_1 :
(ℓ : Std.DTreeMap.Internal.Impl α β) →
(hℓ₁ : ℓ.Bal... | null | true |
MeasureTheory.pdf.eq_of_map_eq_withDensity' | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω}
{μ : MeasureTheory.Measure E} [MeasureTheory.SigmaFinite μ] {X : Ω → E} [MeasureTheory.HasPDF X ℙ μ]
(f : E → ENNReal),
AEMeasurable f μ → (MeasureTheory.Measure.map X ℙ = μ.withDensity f ↔ MeasureTheo... | null | true |
_private.Mathlib.Computability.TuringMachine.ToPartrec.0.Option.getD.match_1.splitter | Mathlib.Computability.TuringMachine.ToPartrec | {α : Type u_1} →
(motive : Option α → Sort u_2) → (opt : Option α) → ((x : α) → motive (some x)) → (Unit → motive none) → motive opt | null | true |
Lean.Meta.Grind.instInhabitedEMatchTheorem | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheorem | null | true |
mabs_div_lt_of_one_le_of_lt | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b n : G},
1 ≤ a → a < n → 1 ≤ b → b < n → |a / b|ₘ < n | `|a / b|ₘ < n` if `1 ≤ a < n` and `1 ≤ b < n`. | true |
lebesgue_number_of_compact_open | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type ua} [inst : UniformSpace α] {K U : Set α},
IsCompact K → IsOpen U → K ⊆ U → ∃ V ∈ uniformity α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U | A useful consequence of the Lebesgue number lemma: given any compact set `K` contained in an
open set `U`, we can find an (open) entourage `V` such that the ball of size `V` about any point of
`K` is contained in `U`. | true |
_private.Mathlib.Topology.EMetricSpace.Basic.0.EMetric.nontrivial_iff_nontrivialTopology._simp_1_3 | Mathlib.Topology.EMetricSpace.Basic | ∀ {α : Type u} [inst : PseudoEMetricSpace α] {x y : α}, Inseparable x y = (edist x y = 0) | null | false |
Array.mergeDedupWith.go._unary._proof_2 | Batteries.Data.Array.Merge | ∀ {α : Type u_1} (xs ys acc : Array α) (i j : ℕ),
¬i ≥ xs.size →
∀ (hj : ¬j ≥ ys.size),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun acc i => PSigma.casesOn i fun i j => xs.size + ys.size - (i + j))
⟨acc.push ys[j], ⟨i, j + 1⟩⟩ ⟨acc, ⟨i, j⟩⟩ | null | false |
Submodule.smul_le_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{s t : SetSemiring A} {M N : Submodule R A}, SetSemiring.down s ⊆ SetSemiring.down t → M ≤ N → s • M ≤ t • N | null | true |
Valuation.map_add_eq_of_lt_right | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommMonoidWithZero Γ₀] (v : Valuation R Γ₀)
{x y : R}, v x < v y → v (x + y) = v y | null | true |
ChainComplex.fromSingle₀Equiv._proof_4 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V),
Function.LeftInverse (fun f => HomologicalComplex.mkHomFromSingle f ⋯) fun f => f.f 0 | null | false |
AlgEquiv.casesOn | Mathlib.Algebra.Algebra.Equiv | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] →
[inst_2 : Semiring B] →
[inst_3 : Algebra R A] →
[inst_4 : Algebra R B] →
{motive : (A ≃ₐ[R] B) → Sort u_1} →
(t : A ≃ₐ[R] B) →
... | null | false |
MeasureTheory.measureReal_abs_dual_gt_le_integral_charFunDual | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mE : MeasurableSpace E}
[OpensMeasurableSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ] (L : StrongDual ℝ E)
{r : ℝ},
0 < r → μ.real {x | r < |L x|} ≤ 2⁻¹ * r * ‖∫ (t : ℝ) in -2 * r⁻¹..2 * r⁻¹, 1 - MeasureTheo... | For a probability measure on a normed space `E` and `L : Dual ℝ E`, a bound on the measure
of the set `{x | r < |L x|}` in terms of the integral of the characteristic function. | true |
finRotate_last | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ}, (finRotate (n + 1)) (Fin.last n) = 0 | null | true |
CategoryTheory.Limits.zeroProdIso | Mathlib.CategoryTheory.Limits.Constructions.ZeroObjects | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] → (X : C) → 0 ⨯ X ≅ X | A zero object is a left unit for categorical product. | true |
Finset.instAddTorsorForall | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} → [inst : Ring k] → {ι : Type u_4} → AddTorsor (ι → k) (ι → k) | null | true |
_private.Mathlib.Geometry.Euclidean.Similarity.0.EuclideanGeometry.similar_of_side_angle_side._proof_1_10 | Mathlib.Geometry.Euclidean.Similarity | ∀ {P₁ : Type u_1} {P₂ : Type u_2} [inst : MetricSpace P₁] [inst_1 : MetricSpace P₂] {a b c : P₁} {a' b' c' : P₂},
dist c a = dist a b / dist a' b' * dist c' a' → dist c a = dist a b / dist a' b' * dist c' a' | null | false |
Quotient.liftOn₂.congr_simp | Mathlib.Data.Fintype.Quotient | ∀ {α : Sort uA} {β : Sort uB} {φ : Sort uC} {s₁ : Setoid α} {s₂ : Setoid β} (q₁ q₁_1 : Quotient s₁),
q₁ = q₁_1 →
∀ (q₂ q₂_1 : Quotient s₂),
q₂ = q₂_1 →
∀ (f f_1 : α → β → φ) (e_f : f = f_1)
(c : ∀ (a₁ : α) (b₁ : β) (a₂ : α) (b₂ : β), a₁ ≈ a₂ → b₁ ≈ b₂ → f a₁ b₁ = f a₂ b₂),
q₁.lif... | null | true |
MulMemClass.subtype | Mathlib.Algebra.Group.Subsemigroup.Defs | {M : Type u_1} →
{A : Type u_3} → [inst : Mul M] → [inst_1 : SetLike A M] → [hA : MulMemClass A M] → (S' : A) → ↥S' →ₙ* M | The natural semigroup hom from a subsemigroup of semigroup `M` to `M`. | true |
Std.Sat.AIG.RefVec.IfInput.rec | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Sat.AIG.RefVec.IfInput aig w → Sort u} →
((discr : aig.Ref) → (lhs rhs : aig.RefVec w) → motive { discr := discr, lhs := lhs, rhs := rhs }) →
(t : Std.Sat... | null | false |
MeasureTheory.condExpL1CLM_indicatorConst | Mathlib.MeasureTheory.Function.ConditionalExpectation.CondexpL1 | ∀ {α : Type u_1} {F' : Type u_3} [inst : NormedAddCommGroup F'] [inst_1 : NormedSpace ℝ F'] {m m0 : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {hm : m ≤ m0} [inst_2 : MeasureTheory.SigmaFinite (μ.trim hm)] {s : Set α}
[inst_3 : CompleteSpace F'] (hs : MeasurableSet s) (hμs : μ s ≠ ⊤) (x : F'),
(MeasureTheor... | null | true |
InnerProductSpace.canonicalCovariantTensor.congr_simp | Mathlib.Analysis.Distribution.DerivNotation | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E],
InnerProductSpace.canonicalCovariantTensor E = InnerProductSpace.canonicalCovariantTensor E | null | true |
UniformOnFun.gen_mono | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} {S S' : Set α} {V V' : Set (β × β)},
S' ⊆ S → V ⊆ V' → UniformOnFun.gen 𝔖 S V ⊆ UniformOnFun.gen 𝔖 S' V' | `UniformOnFun.gen` is antitone in the first argument and monotone in the second. | true |
_private.Lean.Meta.Basic.0.Lean.Meta.ExprConfigCacheKey.mk.inj | Lean.Meta.Basic | ∀ {expr : Lean.Expr} {configKey : UInt64} {expr_1 : Lean.Expr} {configKey_1 : UInt64},
{ expr := expr, configKey := configKey } = { expr := expr_1, configKey := configKey_1 } →
expr = expr_1 ∧ configKey = configKey_1 | null | true |
AddSemigrp.Hom.casesOn | Mathlib.Algebra.Category.Semigrp.Basic | {A B : AddSemigrp} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →ₙ+ ↑B) → motive { hom' := hom' }) → motive t | null | false |
invertibleTwo._proof_2 | Mathlib.Algebra.CharP.Invertible | (1 + 1).AtLeastTwo | null | false |
BitVec.not_lt_zero._simp_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (x < 0#w) = False | null | false |
imp_false | Init.Core | ∀ {a : Prop}, a → False ↔ ¬a | null | true |
CategoryTheory.categoryFree._proof_5 | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u_1) [inst : CommRing R] (C : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
{W X Y Z : CategoryTheory.Free R C} (f : (W ⟶ X) →₀ R) (g : (X ⟶ Y) →₀ R) (h : (Y ⟶ Z) →₀ R),
((f.sum fun f' s => g.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t).sum fun f' s =>
h.su... | null | false |
ergodic_smul_of_denseRange_pow | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : Monoid M] [inst_5 : TopologicalSpace M] [inst_6 : MulAction M X] [ContinuousSMul M X] {g : M},
(DenseRange fun x => g ^ x) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMeasur... | If a monoid `M` continuously acts on an R₁ topological space `X`,
`g` is an element of `M` such that its natural powers are dense in `M`,
and `μ` is a finite inner regular measure on `X` which is ergodic with respect to the action of `M`,
then the scalar multiplication by `g` is an ergodic map. | true |
_private.Mathlib.Data.Set.Prod.0.Set.compl_prod_eq_union._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), (s ×ˢ t)ᶜ = sᶜ ×ˢ Set.univ ∪ Set.univ ×ˢ tᶜ | null | false |
Derivation.leibniz | Mathlib.RingTheory.Derivation.Basic | ∀ {R : Type u_1} {A : Type u_2} {M : Type u_4} [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] (D : Derivation R A M)
(a b : A), D (a * b) = a • D b + b • D a | null | true |
upperPolar_empty | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop), upperPolar r ∅ = Set.univ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.