name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Diff.instToStringAction.match_1 | Lean.Util.Diff | (motive : Lean.Diff.Action → Sort u_1) →
(x : Lean.Diff.Action) →
(Unit → motive Lean.Diff.Action.insert) →
(Unit → motive Lean.Diff.Action.delete) → (Unit → motive Lean.Diff.Action.skip) → motive x | null | false |
EReal.toReal | Mathlib.Data.EReal.Basic | EReal → ℝ | The map from extended reals to reals sending infinities to zero. | true |
_private.Lean.Parser.Command.0.Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.monotonicityBy.formatter_147 | Lean.Parser.Command | IO Unit | null | false |
Lean.Sym.Char.eq_eq_false | Init.Sym.Lemmas | ∀ (a b : Char), decide (a = b) = false → (a = b) = False | null | true |
_private.Lean.Elab.MutualDef.0.Lean.Elab.Term.elabMutualDef.finishElab._sparseCasesOn_2 | Lean.Elab.MutualDef | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
ZNum.mod_to_int | Mathlib.Data.Num.ZNum | ∀ (n d : ZNum), ↑(n % d) = ↑n % ↑d | null | true |
InvImage.refl | Mathlib.Order.RelClasses | ∀ {α : Sort u_1} {β : Sort u_2} {r : α → α → Prop} (f : β → α) [Std.Refl r], Std.Refl (InvImage r f) | null | true |
Std.Internal.UV.Loop.Options.mk.noConfusion | Std.Internal.UV.Loop | {P : Sort u} →
{accumulateIdleTime blockSigProfSignal accumulateIdleTime' blockSigProfSignal' : Bool} →
{ accumulateIdleTime := accumulateIdleTime, blockSigProfSignal := blockSigProfSignal } =
{ accumulateIdleTime := accumulateIdleTime', blockSigProfSignal := blockSigProfSignal' } →
(accumulateIdleT... | null | false |
Matrix.vecMulLinear_transpose | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_1} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] (M : Matrix m n R),
M.transpose.vecMulLinear = M.mulVecLin | null | true |
Std.Tactic.BVDecide.Reflect.BitVec.add_congr | Std.Tactic.BVDecide.Reflect | ∀ (w : ℕ) (lhs rhs lhs' rhs' : BitVec w), lhs' = lhs → rhs' = rhs → lhs' + rhs' = lhs + rhs | null | true |
SheafOfModules.pushforwardSections_coe | Mathlib.Algebra.Category.ModuleCat.Sheaf.PullbackFree | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{J : CategoryTheory.GrothendieckTopology C} {K : CategoryTheory.GrothendieckTopology D}
{F : CategoryTheory.Functor C D} {S : CategoryTheory.Sheaf J RingCat} {R : CategoryTheory.Sheaf K RingCat}
... | null | true |
SignType.instBoundedOrder | Mathlib.Basic.Sign.Defs | BoundedOrder SignType | null | true |
_private.Mathlib.Topology.MetricSpace.Gluing.0.Metric.glueDist_swap.match_1_1 | Mathlib.Topology.MetricSpace.Gluing | ∀ {X : Type u_1} {Y : Type u_2} (motive : X ⊕ Y → X ⊕ Y → Prop) (x x_1 : X ⊕ Y),
(∀ (val val_1 : X), motive (Sum.inl val) (Sum.inl val_1)) →
(∀ (val val_1 : Y), motive (Sum.inr val) (Sum.inr val_1)) →
(∀ (val : X) (val_1 : Y), motive (Sum.inl val) (Sum.inr val_1)) →
(∀ (val : Y) (val_1 : X), motive ... | null | false |
UniqueAdd.addHom_preimage | Mathlib.Algebra.Group.UniqueProds.Basic | ∀ {G : Type u_1} {H : Type u_2} [inst : Add G] [inst_1 : Add H] (f : G →ₙ+ H) (hf : Function.Injective ⇑f) (a0 b0 : G)
{A B : Finset H}, UniqueAdd A B (f a0) (f b0) → UniqueAdd (A.preimage ⇑f ⋯) (B.preimage ⇑f ⋯) a0 b0 | `UniqueAdd` is preserved by inverse images under injective, additive maps. | true |
Set.Nonempty.of_vadd_right | Mathlib.Algebra.Group.Pointwise.Set.Scalar | ∀ {α : Type u_1} {β : Type u_2} [inst : VAdd α β] {s : Set α} {t : Set β}, (s +ᵥ t).Nonempty → t.Nonempty | null | true |
Prod.normedRing._proof_3 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedRing α] [inst_1 : NormedRing β] (a : α × β), 1 * a = a | null | false |
Polynomial.coeff_eq_zero_of_lt_trailingDegree | Mathlib.Algebra.Polynomial.Degree.TrailingDegree | ∀ {R : Type u} {n : ℕ} [inst : Semiring R] {p : Polynomial R}, ↑n < p.trailingDegree → p.coeff n = 0 | null | true |
ProofWidgets.Penrose.DiagramProps.maxOptSteps | ProofWidgets.Component.PenroseDiagram | ProofWidgets.Penrose.DiagramProps → ℕ | Maximum number of optimization steps to take before showing the diagram.
Optimization may converge earlier, before taking this many steps. | true |
IsSimpleOrder.instFinite | Mathlib.Order.Atoms.Finite | ∀ {α : Type u_1} [inst : LE α] [inst_1 : BoundedOrder α] [IsSimpleOrder α], Finite α | null | true |
CompactlySupportedContinuousMap.mk.sizeOf_spec | Mathlib.Topology.ContinuousMap.CompactlySupported | ∀ {α : Type u_5} {β : Type u_6} [inst : TopologicalSpace α] [inst_1 : Zero β] [inst_2 : TopologicalSpace β]
[inst_3 : SizeOf α] [inst_4 : SizeOf β] (toContinuousMap : C(α, β))
(hasCompactSupport' : HasCompactSupport toContinuousMap.toFun),
sizeOf { toContinuousMap := toContinuousMap, hasCompactSupport' := hasComp... | null | true |
CochainComplex.HomComplex.leftHomologyData'._proof_5 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexCohomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
(K L : CochainComplex C ℤ) (n m p : ℤ) (hm : n + 1 = m) (hp : m + 1 = p)
(s :
CategoryTheory.Limits.Cofork
((CochainComplex.HomComplex.Cocycle.isKernel K L m p hp).lift
(CategoryTheory.Limits.Ker... | null | false |
Std.Http.Internal.Char.vchar | Std.Http.Internal.Char | Char → Bool | vchar = %x21-7E
; Visible (printing) ASCII characters.
| true |
_private.Mathlib.NumberTheory.FundamentalDiscriminant.0.Int.isFundamentalDiscr_iff_forall_prime._simp_1_4 | Mathlib.NumberTheory.FundamentalDiscriminant | ∀ {p q : Prop}, (¬(p ∨ q)) = (¬p ∧ ¬q) | null | false |
Std.Slice.Internal.SubarrayData.mk._flat_ctor | Init.Data.Array.Subarray | {α : Type u} →
(array : Array α) → (start stop : ℕ) → start ≤ stop → stop ≤ array.size → Std.Slice.Internal.SubarrayData α | null | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_7 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | null | false |
_private.Mathlib.Data.Set.Insert.0.Set.ssubset_insert._proof_1_1 | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, a ∉ s → s ⊂ insert a s | null | false |
hasFDerivAt_comp_add_right | Mathlib.Analysis.Calculus.FDeriv.Add | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{f' : E →L[𝕜] F} {x : E} (a : E), HasFDerivAt (fun x => f (x + a)) f' x ↔ HasFDerivAt f f' (x + a) | null | true |
Nat.clog_zero_right | Mathlib.Data.Nat.Log | ∀ (b : ℕ), Nat.clog b 0 = 0 | null | true |
hasDerivWithinAt_sdiff_singleton | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s : Set 𝕜},
HasDerivWithinAt f f' (s \ {x}) x ↔ HasDerivWithinAt f f' s x | null | true |
CategoryTheory.nerve.σ₀_mk₀_eq | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (x : C),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.SimplicialObject.σ (CategoryTheory.nerve C) 0))
(CategoryTheory.ComposableArrows.mk₀ x) =
CategoryTheory.ComposableArrows.mk₁ (CategoryTheory.CategoryStruct.id x) | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Metric.0.SimpleGraph.Reachable.dist_triangle_right._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {v w : V},
G.Reachable v w → ∀ (u : V), G.Reachable u w → ↑(G.dist u w) ≤ ↑(G.dist u v) + ↑(G.dist v w) | null | false |
_private.Mathlib.Probability.Kernel.Composition.MeasureCompProd.0.MeasureTheory.Measure.compProd_eq_zero_iff._simp_1_1 | Mathlib.Probability.Kernel.Composition.MeasureCompProd | ∀ {α : Type u_1} {mα : MeasurableSpace α} {μ : MeasureTheory.Measure α}, (μ = 0) = (μ Set.univ = 0) | null | false |
fixingSubgroup_union | Mathlib.GroupTheory.GroupAction.FixingSubgroup | ∀ (M : Type u_1) (α : Type u_2) [inst : Group M] [inst_1 : MulAction M α] {s t : Set α},
fixingSubgroup M (s ∪ t) = fixingSubgroup M s ⊓ fixingSubgroup M t | Fixing subgroup of union is intersection | true |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula.0.WeierstrassCurve.Affine.den_duplication_eq_zero_iff._proof_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.Affine.Formula | ∀ {R : Type u_1} [inst : CommRing R] {W' : WeierstrassCurve.Affine R} {x y : R},
2 * y + W'.a₁ * x + W'.a₃ = 0 ↔ y = -y - W'.a₁ * x - W'.a₃ | null | false |
_private.Mathlib.Order.Interval.Set.UnorderedInterval.0.Set.forall_uIoc_iff._simp_1_2 | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {a b c : Prop}, (a ∨ b → c) = ((a → c) ∧ (b → c)) | null | false |
_private.Mathlib.CategoryTheory.ComposableArrows.Basic.0.CategoryTheory.ComposableArrows.homMk._proof_3 | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {n : ℕ} (k i j : ℕ), i + k = j → ¬i ≤ j → False | null | false |
Std.Tactic.BVDecide.BVExpr.decEq._proof_129 | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w : ℕ} (lw : ℕ) (llhs : Std.Tactic.BVDecide.BVExpr w) (lrhs : Std.Tactic.BVDecide.BVExpr lw) (w_1 start : ℕ)
(expr : Std.Tactic.BVDecide.BVExpr w_1), ¬llhs.shiftLeft lrhs = Std.Tactic.BVDecide.BVExpr.extract start w expr | null | false |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_24 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (k : ℕ), k + 1 ≤ tail.length → -1 * ↑k + 1 ≤ 0 → k - 1 < tail.length | null | false |
RBTree.RBNode.exists_find?_insert_self | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {c : RBTree.RBColor} {n : ℕ} {v : α} [Std.TransCmp cmp]
[RBTree.RBNode.IsCut cmp cut] {t : RBTree.RBNode α},
t.Balanced c n →
RBTree.RBNode.Ordered cmp t →
cut v = Ordering.eq → ∃ x, RBTree.RBNode.find? cut (RBTree.RBNode.insert cmp t v) = som... | null | true |
LinearMap.finrank_maxGenEigenspace_eq | Mathlib.LinearAlgebra.Eigenspace.Zero | ∀ {K : Type u_2} {M : Type u_3} [inst : Field K] [inst_1 : AddCommGroup M] [inst_2 : Module K M]
[inst_3 : Module.Finite K M] (φ : Module.End K M) (μ : K),
Module.finrank K ↥(φ.maxGenEigenspace μ) = Polynomial.rootMultiplicity μ (LinearMap.charpoly φ) | null | true |
MvPolynomial.universalFactorizationMapPresentation_val | Mathlib.RingTheory.Polynomial.UniversalFactorizationRing | ∀ (R : Type u_1) [inst : CommRing R] (n m k : ℕ) (hn : n = m + k) (a : Fin m ⊕ Fin k),
(MvPolynomial.universalFactorizationMapPresentation R n m k hn).val a =
Sum.elim (fun x => MvPolynomial.X x ⊗ₜ[R] 1) (fun x => 1 ⊗ₜ[R] MvPolynomial.X x) a | null | true |
AlgebraicGeometry.isLocallyNoetherian_iff_of_affine_openCover | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} (𝒰 : X.OpenCover) [∀ (i : 𝒰.I₀), AlgebraicGeometry.IsAffine (𝒰.X i)],
AlgebraicGeometry.IsLocallyNoetherian X ↔ ∀ (i : 𝒰.I₀), IsNoetherianRing ↑((𝒰.X i).presheaf.obj (Opposite.op ⊤)) | A version of `isLocallyNoetherian_iff_of_iSup_eq_top` using `Scheme.OpenCover`. | true |
Convex.mul_sub_lt_image_sub_of_lt_deriv | Mathlib.Analysis.Calculus.Deriv.MeanValue | ∀ {D : Set ℝ},
Convex ℝ D →
∀ {f : ℝ → ℝ},
ContinuousOn f D →
DifferentiableOn ℝ f (interior D) →
∀ {C : ℝ}, (∀ x ∈ interior D, C < deriv f x) → ∀ x ∈ D, ∀ y ∈ D, x < y → C * (y - x) < f y - f x | Let `f` be a function continuous on a convex (or, equivalently, connected) subset `D`
of the real line. If `f` is differentiable on the interior of `D` and `C < f'`, then
`f` grows faster than `C * x` on `D`, i.e., `C * (y - x) < f y - f x` whenever `x, y ∈ D`,
`x < y`. | true |
CategoryTheory.Functor.ι_leftKanExtensionObjIsoColimit_hom_assoc | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {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] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] (X : D) (f : Ca... | null | true |
Std.DTreeMap.Internal.RciSliceData.mk.sizeOf_spec | Std.Data.DTreeMap.Internal.Zipper | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [inst_1 : SizeOf α] [inst_2 : (a : α) → SizeOf (β a)]
(treeMap : Std.DTreeMap.Internal.Impl α β) (range : Std.Rci α),
sizeOf { treeMap := treeMap, range := range } = 1 + sizeOf treeMap + sizeOf range | null | true |
imp_iff_not_or | Mathlib.Basic.Logic.Basic | ∀ {a b : Prop}, a → b ↔ ¬a ∨ b | null | true |
IsTopologicalGroup.leftUniformSpace | Mathlib.Topology.Algebra.IsUniformGroup.Defs | (G : Type u_1) → [inst : Group G] → [inst_1 : TopologicalSpace G] → [IsTopologicalGroup G] → UniformSpace G | The left uniformity on a topological group (as opposed to the right uniformity).
Warning: in general the right and left uniformities do not coincide and so one does not obtain a
`IsUniformGroup` structure. Two important special cases where they _do_ coincide are for
commutative groups (see `isUniformGroup_of_commGroup... | true |
Real.one_lt_sqrt_two | Mathlib.Analysis.Real.Sqrt | 1 < √2 | null | true |
_private.Lean.Meta.Injective.0.Lean.Meta.andProjections.go | Lean.Meta.Injective | Lean.Expr → Lean.Expr → Array Lean.Expr → Lean.MetaM (Array Lean.Expr) | null | true |
_private.Mathlib.CategoryTheory.WithTerminal.Basic.0.CategoryTheory.WithTerminal.widePullbackShapeEquivMap.match_3 | Mathlib.CategoryTheory.WithTerminal.Basic | {J : Type u_1} →
(motive :
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ x ⟶
CategoryTheory.WithTerminal.widePullbackShapeEquivObj✝ y) →
Sort u_2) →
(x y : CategoryTheory.Limits.WidePullbackShape J) →
(f :
... | null | false |
SMulPosMono | Mathlib.Algebra.Order.Module.Defs | (α : Type u_1) → (β : Type u_2) → [SMul α β] → [Preorder α] → [Preorder β] → [Zero β] → Prop | Typeclass for monotonicity of scalar multiplication by nonnegative elements on the left,
namely `a₁ ≤ a₂ → a₁ • b ≤ a₂ • b` if `0 ≤ b`.
You should usually not use this very granular typeclass directly, but rather a typeclass like
`IsOrderedModule`. | true |
Mathlib.CrossRef.getPiBaseTopic? | Mathlib.Tactic.CrossRefAttribute | Lean.TSyntax `Mathlib.CrossRef.pibaseTopic → Option Mathlib.CrossRef.PiBaseTopic | Get the `PiBaseTopic` from a syntax key. | true |
_private.Batteries.Data.List.Lemmas.0.List.pos_findIdxNth_getElem._proof_1_10 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (head : α) (tail : List α) {n : ℕ}
{h : List.findIdxNth p (head :: tail) n < (head :: tail).length},
¬n = 0 → ¬p head = true → List.findIdxNth p tail n < tail.length | null | false |
_private.Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo.0.Matrix.isParabolic_iff_exists._simp_1_5 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | ∀ {n : Type u_3} {α : Type u_8} [inst : Semiring α] [inst_1 : DecidableEq n] [inst_2 : Fintype n] [Nonempty n]
{r s : α}, ((Matrix.scalar n) r = (Matrix.scalar n) s) = (r = s) | null | false |
Lean.Compiler.LCNF.Code.ctorElimType | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → {motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} → ℕ → Sort (max 1 u) | null | false |
Std.instCommutativeAnd | Init.Core | Std.Commutative And | null | true |
IsDenseInducing.casesOn | Mathlib.Topology.DenseEmbedding | {α : Type u_1} →
{β : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
{i : α → β} →
{motive : IsDenseInducing i → Sort u} →
(t : IsDenseInducing i) →
((toIsInducing : Topology.IsInducing i) → (dense : DenseRange i) → motive ⋯) → motive t | null | false |
ModuleCat.monModuleEquivalenceAlgebra._proof_29 | Mathlib.CategoryTheory.Monoidal.Internal.Module | ∀ {R : Type u_1} [inst : CommRing R] (A : AlgCat R) (x : R), id ((algebraMap R ↑A) x) = id ((algebraMap R ↑A) x) | null | false |
Lean.Elab.Term.ContainsPendingMVar.visit | Lean.Elab.Term.TermElabM | Lean.Expr → Lean.Elab.Term.ContainsPendingMVar.M Unit | See `containsPostponedTerm` | true |
IntermediateField.AdjoinSimple.norm_gen_eq_prod_roots | Mathlib.RingTheory.Norm.Basic | ∀ {K : Type u_4} {L : Type u_5} {F : Type u_6} [inst : Field K] [inst_1 : Field L] [inst_2 : Field F]
[inst_3 : Algebra K L] [inst_4 : Algebra K F] (x : L),
(Polynomial.map (algebraMap K F) (minpoly K x)).Splits →
(algebraMap K F) ((Algebra.norm K) (IntermediateField.AdjoinSimple.gen K x)) = ((minpoly K x).aroo... | null | true |
SSet.prodStdSimplex.pairingCore.IsType₂.type₁_index | Mathlib.AlgebraicTopology.SimplicialSet.AnodyneExtensions.UnionProd | ∀ {m : ℕ} {k : Fin (m + 1)} {n : ℕ} {x : ((SSet.horn (m + 1) k.castSucc).unionProd (SSet.boundary n)).N}
(hx : SSet.prodStdSimplex.pairingCore.IsType₂ x) {d : ℕ} (hd : x.dim = d),
(hx.type₁ hd).index = SSet.prodStdSimplex.pairingCore.min x hd | null | true |
IsTorsion.subgroup | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : Group G], IsMulTorsion G → ∀ (H : Subgroup G), IsMulTorsion ↥H | **Alias** of `IsMulTorsion.subgroup`.
---
Subgroups of torsion groups are torsion groups. | true |
_private.Lean.Compiler.LCNF.ToLCNF.0.Lean.Compiler.LCNF.ToLCNF.State.seq | Lean.Compiler.LCNF.ToLCNF | Lean.Compiler.LCNF.ToLCNF.State✝ → Array Lean.Compiler.LCNF.ToLCNF.Element✝ | LCNF sequence, we chain it to create a LCNF `Code` object. | true |
MvPolynomial.instIsCancelAddOfIsLeftCancelAdd | Mathlib.Algebra.MvPolynomial.Division | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] [IsLeftCancelAdd R], IsCancelAdd (MvPolynomial σ R) | null | true |
PolishSpace.measurableEquivNatBoolOfNotCountable._proof_1 | Mathlib.MeasureTheory.Constructions.Polish.Basic | ∀ {α : Type u_1}, ¬Countable α → ¬Set.univ.Countable | null | false |
_private.Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap.0.ContinuousLinearMap.toLinearMap₁₂_injective._simp_1_2 | Mathlib.Topology.Algebra.Module.Spaces.ContinuousLinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {f g : M₁ →SL[σ₁₂] M₂}... | null | false |
LipschitzWith.integral_inv_smul_sub_mul_tendsto_integral_lineDeriv_mul | Mathlib.Analysis.Calculus.Rademacher | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
{C : NNReal} {f g : E → ℝ} {μ : MeasureTheory.Measure E} [FiniteDimensional ℝ E] [μ.IsAddHaarMeasure],
LipschitzWith C f →
MeasureTheory.Integrable g μ →
∀ (v : E),
Filter.Tendsto ... | null | true |
MeasureTheory.hittingBtwn_mem_Icc | Mathlib.Probability.Process.HittingTime | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : ConditionallyCompleteLinearOrder ι] {u : ι → Ω → β} {s : Set β}
{n m : ι}, n ≤ m → ∀ (ω : Ω), MeasureTheory.hittingBtwn u s n m ω ∈ Set.Icc n m | null | true |
Homeomorph.inv.congr_simp | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ (G : Type u_4) [inst : TopologicalSpace G] [inst_1 : InvolutiveInv G] [inst_2 : ContinuousInv G],
Homeomorph.inv G = Homeomorph.inv G | null | true |
String.Slice.Pattern.Model.IsLongestRevMatch.isRevMatch | Init.Data.String.Lemmas.Pattern.Basic | ∀ {ρ : Type} {pat : ρ} [inst : String.Slice.Pattern.Model.PatternModel pat] {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatch pat pos → String.Slice.Pattern.Model.IsRevMatch pat pos | null | true |
Subgroup.pi_le_iff | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_2} {f : η → Type u_3} [inst : (i : η) → Group (f i)] [inst_1 : DecidableEq η] [Finite η]
{H : (i : η) → Subgroup (f i)} {J : Subgroup ((i : η) → f i)},
Subgroup.pi Set.univ H ≤ J ↔ ∀ (i : η), Subgroup.map (MonoidHom.mulSingle f i) (H i) ≤ J | For finite index types, the `Subgroup.pi` is generated by the embeddings of the groups. | true |
_private.Mathlib.Combinatorics.Additive.ErdosGinzburgZiv.0.Int.erdos_ginzburg_ziv_prime | Mathlib.Combinatorics.Additive.ErdosGinzburgZiv | ∀ {ι : Type u_1} {p : ℕ} [Fact (Nat.Prime p)] {s : Finset ι} (a : ι → ℤ),
s.card = 2 * p - 1 → ∃ t ⊆ s, t.card = p ∧ ↑p ∣ ∑ i ∈ t, a i | The prime case of the **Erdős–Ginzburg–Ziv theorem** for `ℤ`.
Any sequence of `2 * p - 1` elements of `ℤ` contains a subsequence of `p` elements whose sum is
divisible by `p`. | true |
Lean.Meta.Grind.getEqc | Lean.Meta.Tactic.Grind.Types | Lean.Expr → optParam Bool false → Lean.Meta.Grind.GoalM (List Lean.Expr) | Returns expressions in the given expression equivalence class. | true |
CategoryTheory.ProfunctorCore.map_comp | Mathlib.CategoryTheory.Profunctor.Basic | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.ProfunctorCore.{w, v₁, v₂, u₁, u₂} C D) {X₁ X₂ X₃ : C} {Y₁ Y₂ Y₃ : D} (f : X₁ ⟶ X₂)
(f' : X₂ ⟶ X₃) (g : Y₁ ⟶ Y₂) (g' : Y₂ ⟶ Y₃),
self.map (CategoryTheory.CategoryStruct.co... | null | true |
CategoryTheory.Limits.reflectsColimitsOfSize_of_rightOp | Mathlib.CategoryTheory.Limits.Preserves.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor Cᵒᵖ D) [CategoryTheory.Limits.ReflectsLimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F.rightOp],
CategoryTheory.Limits.ReflectsColimitsOfSize.{w, w', v₁, v₂, u₁, u₂} F | If `F.rightOp : C ⥤ Dᵒᵖ` reflects limits, then `F : Cᵒᵖ ⥤ D` reflects colimits. | true |
_private.Mathlib.Topology.UniformSpace.UniformConvergenceTopology.0.UniformFun.«_aux_Mathlib_Topology_UniformSpace_UniformConvergenceTopology___macroRules__private_Mathlib_Topology_UniformSpace_UniformConvergenceTopology_0_UniformFun_term𝒰(_,_,_)_1» | Mathlib.Topology.UniformSpace.UniformConvergenceTopology | Lean.Macro | null | false |
Std.Http.instReprVersion | Std.Http.Data.Version | Repr Std.Http.Version | null | true |
Subgroup.exists_index_le_card_of_leftCoset_cover | Mathlib.GroupTheory.CosetCover | ∀ {G : Type u_1} [inst : Group G] {ι : Type u_2} {H : ι → Subgroup G} {g : ι → G} {s : Finset ι},
⋃ i ∈ s, g i • ↑(H i) = Set.univ → ∃ i ∈ s, (H i).FiniteIndex ∧ (H i).index ≤ s.card | B. H. Neumann Lemma :
If a finite family of cosets of subgroups covers the group, then at least one
of these subgroups has index not exceeding the number of cosets. | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int32.reduceMul.declare_206._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.3685453738._hygCtx._hyg.87 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
Lean.Meta.Grind.AC.Struct._sizeOf_1 | Lean.Meta.Tactic.Grind.AC.Types | Lean.Meta.Grind.AC.Struct → ℕ | null | false |
Plausible.Testable.minimizeAux | Plausible.Testable | {α : Sort u_1} →
[inst : Plausible.SampleableExt α] →
{β : α → Prop} →
[(x : α) → Plausible.Testable (β x)] →
Plausible.Configuration →
String →
Plausible.SampleableExt.proxy α →
ℕ →
OptionT Plausible.Gen
((x : Plausible.Sampleabl... | Shrink a counter-example `x` by using `Shrinkable.shrink x`, picking the first
candidate that falsifies a property and recursively shrinking that one.
The process is guaranteed to terminate because `shrink x` produces
a proof that all the values it produces are smaller (according to `SizeOf`)
than `x`. | true |
_private.Std.Data.DTreeMap.Internal.Operations.0.Std.DTreeMap.Internal.Impl.alter._proof_8 | Std.Data.DTreeMap.Internal.Operations | ¬0 - 1 ≤ 1 → False | null | false |
_private.Mathlib.CategoryTheory.CofilteredSystem.0.CategoryTheory.Functor.isMittagLeffler_iff_subset_range_comp._simp_1_1 | Mathlib.CategoryTheory.CofilteredSystem | ∀ {J : Type u} [inst : CategoryTheory.Category.{v_1, u} J] (F : CategoryTheory.Functor J (Type v)),
F.IsMittagLeffler = ∀ (j : J), ∃ i f, F.eventualRange j = Set.range ⇑(CategoryTheory.ConcreteCategory.hom (F.map f)) | null | false |
_private.Lean.Server.CodeActions.Provider.0.Lean.CodeAction.findInfoTree?._sparseCasesOn_7 | Lean.Server.CodeActions.Provider | {motive_1 : Lean.Elab.InfoTree → Sort u} →
(t : Lean.Elab.InfoTree) →
((i : Lean.Elab.PartialContextInfo) → (t : Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.context i t)) →
((i : Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) → motive_1 (Lean.Elab.InfoTree.node i chi... | null | false |
MeasureTheory.Submartingale.condExp_sub_nonneg | Mathlib.Probability.Martingale.Basic | ∀ {Ω : Type u_1} {E : Type u_2} {ι : Type u_3} [inst : Preorder ι] {m0 : MeasurableSpace Ω}
{μ : MeasureTheory.Measure Ω} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
{ℱ : MeasureTheory.Filtration ι m0} [CompleteSpace E] [inst_4 : PartialOrder E] [IsOrderedAddMonoid E]
{f : ι → Ω → E}, MeasureTheory... | null | true |
Ordset.mem | Mathlib.Data.Ordmap.Ordset | {α : Type u_1} → [inst : Preorder α] → [DecidableLE α] → α → Ordset α → Bool | O(log n). Does the set contain the element `x`? That is,
is there an element that is equivalent to `x` in the order? | true |
Filter.Germ.LiftPred._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : Filter α} (p : β → Prop) (_f _g : α → β),
_f =ᶠ[l] _g → (∀ᶠ (x : α) in l, p (_f x)) = ∀ᶠ (x : α) in l, p (_g x) | null | false |
Std.ExtTreeSet.ext_contains | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] [Std.LawfulEqCmp cmp] {t₁ t₂ : Std.ExtTreeSet α cmp},
(∀ (k : α), t₁.contains k = t₂.contains k) → t₁ = t₂ | null | true |
CategoryTheory.CommSq.cube_lemma_of_epi | Mathlib.CategoryTheory.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {M000 M001 M010 M011 M100 M101 M110 M111 : C}
(f00x : M000 ⟶ M001) (f01x : M010 ⟶ M011) (f10x : M100 ⟶ M101) (f11x : M110 ⟶ M111) (f0x0 : M000 ⟶ M010)
(f0x1 : M001 ⟶ M011) (f1x0 : M100 ⟶ M110) (f1x1 : M101 ⟶ M111) (fx00 : M000 ⟶ M100) (fx01 : M001 ⟶ M101)
... | null | true |
Ring.DirectLimit.lift_injective | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} [inst_1 : (i : ι) → CommRing (G i)]
{f : (i j : ι) → i ≤ j → G i → G j} (P : Type u_3) [inst_2 : CommRing P] (g : (i : ι) → G i →+* P)
(Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) (f i j hij x) = (g i) x) [Nonempty ι] [IsDirectedOrder ι],
(∀ (i : ι), Fun... | null | true |
affineIndependent_of_ne_of_mem_of_mem_of_notMem | Mathlib.LinearAlgebra.AffineSpace.Independent | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : DivisionRing k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {s : AffineSubspace k P} {p₁ p₂ p₃ : P},
p₁ ≠ p₂ → p₁ ∈ s → p₂ ∈ s → p₃ ∉ s → AffineIndependent k ![p₁, p₂, p₃] | If distinct points `p₁` and `p₂` lie in `s` but `p₃` does not, the three points are affinely
independent. | true |
_private.Lean.Compiler.LCNF.Simp.Main.0.Lean.Compiler.LCNF.Simp.simp.match_18 | Lean.Compiler.LCNF.Simp.Main | (motive : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure → Sort u_1) →
(code : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) →
((decl : Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
(k : Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.pure) → motive (Lean.Compiler.LCNF.C... | null | false |
_private.Mathlib.Topology.Separation.Basic.0.t0Space_iff_inseparable.match_1_1 | Mathlib.Topology.Separation.Basic | ∀ (X : Type u_1) [inst : TopologicalSpace X] (motive : T0Space X → Prop) (x : T0Space X),
(∀ (h : ∀ ⦃x y : X⦄, Inseparable x y → x = y), motive ⋯) → motive x | null | false |
FundamentalGroupoidFunctor.prodToProdTop.match_1 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
(motive :
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B)) →
(x ⟶ y) → Sort u_3) →
(x y :
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
... | null | false |
CategoryTheory.MonoidalCategory.externalProductBifunctorCurried_obj_obj_map_app | Mathlib.CategoryTheory.Monoidal.ExternalProduct.Basic | ∀ (J₁ : Type u₁) (J₂ : Type u₂) (C : Type u₃) [inst : CategoryTheory.Category.{v₁, u₁} J₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} J₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
[inst_3 : CategoryTheory.MonoidalCategory C] (X : CategoryTheory.Functor J₁ C) (X_1 : CategoryTheory.Functor J₂ C)
{X_2 Y : J₁} (f... | null | true |
RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Defs.3348800825._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Defs | Subtype (Eq @RatFunc.definition✝) | null | false |
_private.Mathlib.RingTheory.Valuation.Extension.0.Valuation.HasExtension.val_map_lt_iff._simp_1_1 | Mathlib.RingTheory.Valuation.Extension | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, (¬a ≤ b) = (b < a) | null | false |
PredOrder.prelimitRecOn._proof_4 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_2} {motive : α → Sort u_1} [inst : PartialOrder α] [inst_1 : PredOrder α] (a : α)
(h : ¬Order.IsPredPrelimit a), motive (Order.pred (Classical.choose ⋯)) = motive a | null | false |
Lean.Lsp.ClientCapabilities._sizeOf_inst | Lean.Data.Lsp.Capabilities | SizeOf Lean.Lsp.ClientCapabilities | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Pretriangulated.0.CategoryTheory.Pretriangulated.Triangle.isZero₃_of_isZero₁₂._simp_1_1 | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] (X : C),
CategoryTheory.Limits.IsZero X = (CategoryTheory.CategoryStruct.id X = 0) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.