name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
BitVec.lawful_divSubtractShift | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {args : BitVec.DivModArgs w} (qr : BitVec.DivModState w),
BitVec.DivModState.Poised args qr → BitVec.DivModState.Lawful args (BitVec.divSubtractShift args qr) | We show that the output of `divSubtractShift` is lawful, which tells us that it
obeys the division equation. | true |
ENNReal.toNNReal_sInf | Mathlib.Basic.ENNReal.Operations | ∀ (s : Set ENNReal), (∀ r ∈ s, r ≠ ⊤) → (sInf s).toNNReal = sInf (ENNReal.toNNReal '' s) | null | true |
isScalarTower_closedBall_ball_ball | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜'] [inst_2 : NormedAlgebra 𝕜 𝕜'],
IsScalarTower ↑(Metric.closedBall 0 1) ↑(Metric.ball 0 1) ↑(Metric.ball 0 1) | null | true |
InvolutiveNeg.noConfusion | Mathlib.Algebra.Group.DivInvMonoid | {P : Sort u} →
{A : Type u_2} →
{t : InvolutiveNeg A} →
{A' : Type u_2} → {t' : InvolutiveNeg A'} → A = A' → t ≍ t' → InvolutiveNeg.noConfusionType P t t' | null | false |
Set.div_nonempty | Mathlib.Algebra.Group.Pointwise.Set.Basic | ∀ {α : Type u_2} [inst : Div α] {s t : Set α}, (s / t).Nonempty ↔ s.Nonempty ∧ t.Nonempty | null | true |
_private.Mathlib.Algebra.Order.Field.Power.0.zpow_eq_one_iff_cases₀._simp_1_1 | Mathlib.Algebra.Order.Field.Power | ∀ {α : Type u_1} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] {a b : α} {n : ℤ},
(n = 0 ∨ a = b ∨ a = -b ∧ Even n) = (a ^ n = b ^ n) | null | false |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.MethodSpecs.0.reduceMethod.match_1 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.MethodSpecs | (motive : Option Lean.Meta.Simp.Result → Sort u_1) →
(__do_lift : Option Lean.Meta.Simp.Result) →
((r : Lean.Meta.Simp.Result) → motive (some r)) → ((x : Option Lean.Meta.Simp.Result) → motive x) → motive __do_lift | null | false |
CategoryTheory.locallySmall_self | Mathlib.CategoryTheory.EssentiallySmall | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.LocallySmall.{v, v, u} C | null | true |
Hindman.FS.add | Mathlib.Combinatorics.Hindman | ∀ {M : Type u_1} [inst : AddSemigroup M] {a : Stream' M} {m : M},
Hindman.FS a m → ∃ n, ∀ (m' : M), Hindman.FS (Stream'.drop n a) m' → Hindman.FS a (m + m') | If `m` and `m'` are finite sums in `M`, then so is `m + m'`, provided that `m'`
is obtained from a subsequence of `M` starting sufficiently late. | true |
Quaternion.instCStarRingReal | Mathlib.Analysis.Quaternion | CStarRing (Quaternion ℝ) | null | true |
_private.Mathlib.LinearAlgebra.Matrix.SesquilinearForm.0.mem_pairSelfAdjointMatricesSubmodule._simp_1_4 | Mathlib.LinearAlgebra.Matrix.SesquilinearForm | ∀ {R : Type u_1} {n : Type u_11} {n' : Type u_13} [inst : CommRing R] [inst_1 : Fintype n] [inst_2 : Fintype n']
(J : Matrix n n R) (J' : Matrix n' n' R) (A : Matrix n' n R) (A' : Matrix n n' R) [inst_3 : DecidableEq n]
[inst_4 : DecidableEq n'],
J.IsAdjointPair J' A A' =
((Matrix.toLinearMap₂' R) J).IsAdjoin... | null | false |
Lean.Grind.EqMatch | Init.Grind.Util | {α : Sort u_1} → α → α → {_origin : α} → Prop | Gadget for annotating the equalities in `match`-equations conclusions.
`_origin` is the term used to instantiate the `match`-equation using E-matching.
When `EqMatch a b origin` is `True`, we mark `origin` as a resolved case-split.
| true |
LieAdmissibleRing.ext_iff | Mathlib.Algebra.NonAssoc.LieAdmissible.Defs | ∀ {L : Type u_1} {x y : LieAdmissibleRing L},
x = y ↔
Zero.zero = Zero.zero ∧
Add.add = Add.add ∧
NSMul.nsmul = NSMul.nsmul ∧
Neg.neg = Neg.neg ∧ Sub.sub = Sub.sub ∧ ZSMul.zsmul = ZSMul.zsmul ∧ Mul.mul = Mul.mul | null | true |
AdjoinRoot.instDistribMulActionOfIsScalarTower._proof_4 | Mathlib.RingTheory.AdjoinRoot | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : Monoid S] [inst_2 : DistribMulAction S R]
[inst_3 : IsScalarTower S R R] (f : Polynomial R) (a : S) (x y : AdjoinRoot f), a • (x + y) = a • x + a • y | null | false |
Int.Internal.Linear.cooper_left | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p₁ p₂ : Int.Internal.Linear.Poly) (n : ℕ),
Int.Internal.Linear.cooper_left_cert p₁ p₂ n = true →
Int.Internal.Linear.Poly.denote' ctx p₁ ≤ 0 →
Int.Internal.Linear.Poly.denote' ctx p₂ ≤ 0 →
Int.Internal.Linear.OrOver n (Int.Internal.Linear.cooper_left_split ctx ... | null | true |
List.kunion_kerase | Mathlib.Data.List.Sigma | ∀ {α : Type u} {β : α → Type v} [inst : DecidableEq α] {a : α} {l₁ l₂ : List (Sigma β)},
(List.kerase a l₁).kunion (List.kerase a l₂) = List.kerase a (l₁.kunion l₂) | null | true |
unitOfInvertible._proof_1 | Mathlib.Algebra.Group.Invertible.Basic | ∀ {α : Type u_1} [inst : Monoid α] (a : α) [inst_1 : Invertible a], a * ⅟a = 1 | null | false |
CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinset_obj_map | Mathlib.CategoryTheory.Limits.Constructions.Filtered | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] (α : Type w)
[inst_1 : CategoryTheory.Limits.HasFiniteProducts C] (F : CategoryTheory.Functor (CategoryTheory.Discrete α) C)
{Y x : (Finset (CategoryTheory.Discrete α))ᵒᵖ} (h : Y ⟶ x),
((CategoryTheory.Limits.ProductsFromFiniteCofiltered.liftToFinset C α).o... | null | true |
IsAntichain.image_embedding | Mathlib.Order.Antichain | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} [inst : LE α] [inst_1 : LE β],
IsAntichain (fun x1 x2 => x1 ≤ x2) s → ∀ (φ : α ↪o β), IsAntichain (fun x1 x2 => x1 ≤ x2) (⇑φ '' s) | null | true |
LinearMap.toSpanSingleton_zero | Mathlib.LinearAlgebra.Span.Basic | ∀ (R : Type u_1) (M : Type u_4) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
LinearMap.toSpanSingleton R M 0 = 0 | null | true |
ProofWidgets.instToJsonRpcEncodablePacket.toJson._@.ProofWidgets.Component.FilterDetails.2933785032._hygCtx._hyg.35 | ProofWidgets.Component.FilterDetails | ProofWidgets.RpcEncodablePacket✝ → Lean.Json | null | false |
Lean.Elab.Term.MatchAltView.noConfusionType | Lean.Elab.MatchAltView | Sort u →
{k : Lean.SyntaxNodeKinds} →
Lean.Elab.Term.MatchAltView k → {k' : Lean.SyntaxNodeKinds} → Lean.Elab.Term.MatchAltView k' → Sort u | null | false |
EuclideanGeometry.Sphere.finrank_orthRadius | Mathlib.Geometry.Euclidean.Sphere.OrthRadius | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [FiniteDimensional ℝ V] {s : EuclideanGeometry.Sphere P} {p : P},
p ≠ s.center → Module.finrank ℝ ↥(s.orthRadius p).direction + 1 = Module.finrank ℝ V | null | true |
LinearMap.toAddMonoidHom'._proof_1 | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R₁ : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [inst : Semiring R₁] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R₁ M] [inst_5 : Module R₂ M₂]
{σ₁₂ : R₁ →+* R₂}, LinearMap.toAddMonoidHom 0 = 0 | null | false |
_private.Mathlib.Data.EReal.Basic.0.Mathlib.Meta.Positivity.evalERealToReal._sparseCasesOn_1 | Mathlib.Data.EReal.Basic | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
ruzsaSzemerediNumber.congr_simp | Mathlib.Combinatorics.Extremal.RuzsaSzemeredi | ∀ (α : Type u_1) {inst : DecidableEq α} [inst_1 : DecidableEq α] [inst_2 : Fintype α],
ruzsaSzemerediNumber α = ruzsaSzemerediNumber α | null | true |
HahnSeries.zero_le_orderTop_iff | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] [inst_2 : Zero Γ] {x : HahnSeries Γ R},
0 ≤ x.orderTop ↔ 0 ≤ x.order | null | true |
CategoryTheory.FunctorToTypes.prodMk_snd | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F G : CategoryTheory.Functor C (Type w)} {a : C} (x : F.obj a)
(y : G.obj a),
(CategoryTheory.ConcreteCategory.hom (CategoryTheory.Limits.prod.snd.app a))
(CategoryTheory.FunctorToTypes.prodMk x y) =
y | null | true |
Lean.Parser.scientificLit.parenthesizer | Lean.Parser.Extra | Lean.PrettyPrinter.Parenthesizer | null | true |
Matrix.compl_zero_eq_of_one_sub_one | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ (α : Type u_1) (V : Type u_2) [inst : AddGroup α] [inst_1 : One α] [inst_2 : DecidableEq V] [inst_3 : DecidableEq α],
Matrix.compl 0 = Matrix.of 1 - 1 | null | true |
_private.Mathlib.Tactic.ComputeDegree.0.Mathlib.Tactic.ComputeDegree.twoHeadsArgs.match_14 | Mathlib.Tactic.ComputeDegree | (motive : Lean.Name × Lean.Expr × List Bool → Sort u_1) →
(x : Lean.Name × Lean.Expr × List Bool) →
((ndeg_or_deg_or_coeff : Lean.Name) →
(pol : Lean.Expr) → (and? : List Bool) → motive (ndeg_or_deg_or_coeff, pol, and?)) →
motive x | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.isAltWildcard | Lean.Elab.Tactic.Induction | Lean.Syntax → Bool | Returns true if the alternative is for a wildcard, and that the wildcard is not due to a syntax error. | true |
Module.Presentation.tautologicalSolutionIsPresentationCore._proof_2 | Mathlib.Algebra.Module.Presentation.Tautological | ∀ (A : Type u_2) [inst : Ring A] (M : Type u_3) [inst_1 : AddCommGroup M] [inst_2 : Module A M] {N : Type u_1}
[inst_3 : AddCommGroup N] [inst_4 : Module A N] (x : (Module.Presentation.tautologicalRelations A M).Solution N),
(Module.Presentation.tautologicalSolution A M).postcomp (Module.Presentation.tautologicalRe... | null | false |
Turing.PartrecToTM2.Λ'.ret.injEq | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k k_1 : Turing.PartrecToTM2.Cont'), (Turing.PartrecToTM2.Λ'.ret k = Turing.PartrecToTM2.Λ'.ret k_1) = (k = k_1) | null | true |
Bind.recOn | Init.Prelude | {m : Type u → Type v} →
{motive : Bind m → Sort u_1} →
(t : Bind m) → ((bind : {α β : Type u} → m α → (α → m β) → m β) → motive { bind := bind }) → motive t | null | false |
AffineSubspace.nonempty_iff_ne_bot | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_3} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (Q : AffineSubspace k P), (↑Q).Nonempty ↔ Q ≠ ⊥ | null | true |
CategoryTheory.Mon.mul_def | Mathlib.CategoryTheory.Monoidal.Mon | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {M N : C} [inst_3 : CategoryTheory.MonObj M]
[inst_4 : CategoryTheory.MonObj N],
CategoryTheory.MonObj.mul =
CategoryTheory.CategoryStruct.comp (CategoryTheory.M... | null | true |
IsClosed.right_addCoset | Mathlib.Topology.Algebra.Group.Basic | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [SeparatelyContinuousAdd G] {U : Set G},
IsClosed U → ∀ (x : G), IsClosed (AddOpposite.op x +ᵥ U) | null | true |
nsmul_right_inj | Mathlib.Algebra.Group.Torsion | ∀ {M : Type u_1} [inst : AddMonoid M] [HasUniqueDiv M] {n : ℕ} {a b : M}, n ≠ 0 → (n • a = n • b ↔ a = b) | null | true |
Std.DTreeMap.Internal.Impl.get!_erase | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Std.LawfulEqOrd α] (h : t.WF) {k a : α} [inst_1 : Inhabited (β a)],
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.get! a = if compare k a = Ordering.eq then default else t.get! a | null | true |
IsAddUnit.smul_left | Mathlib.Algebra.Module.End | ∀ {S : Type u_2} {M : Type u_3} [inst : AddCommMonoid M] {x : M} [inst_1 : DistribSMul S M],
IsAddUnit x → ∀ (s : S), IsAddUnit (s • x) | null | true |
FirstOrder.Language.Substructure.FG.map | Mathlib.ModelTheory.FinitelyGenerated | ∀ {L : FirstOrder.Language} {M : Type u_1} [inst : L.Structure M] {N : Type u_2} [inst_1 : L.Structure N]
(f : L.Hom M N) {s : L.Substructure M}, s.FG → (FirstOrder.Language.Substructure.map f s).FG | null | true |
OrderType | Mathlib.Order.Types.Defs | Type (u + 1) | `OrderType.{u}` is the type of linear orders in `Type u`, up to order isomorphism. | true |
Finset.mulOneClass._proof_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_1} [inst : MulOneClass α], ↑{1} = {1} | null | false |
CategoryTheory.le_topology_of_closedSieves_isSheaf | Mathlib.CategoryTheory.Sites.Closed | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J₁ J₂ : CategoryTheory.GrothendieckTopology C},
CategoryTheory.Presieve.IsSheaf J₁ (CategoryTheory.Functor.closedSieves J₂).toFunctor → J₁ ≤ J₂ | If presheaf of `J₁`-closed sieves is a `J₂`-sheaf then `J₁ ≤ J₂`. Note the converse is true by
`classifier_isSheaf` and `isSheaf_of_le`.
| true |
Real.Angle.cos_add_pi_div_two | Mathlib.Analysis.SpecialFunctions.Trigonometric.Angle | ∀ (θ : Real.Angle), (θ + ↑(Real.pi / 2)).cos = -θ.sin | null | true |
_private.Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm.0.IntervalIntegrable.ae_hasDerivAt_integral._proof_1_4 | Mathlib.MeasureTheory.Integral.IntervalIntegral.LebesgueDifferentiationThm | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] {f : ℝ → E} {a b : ℝ},
∀ x ∉ Set.Ioc a b, (fun x => if x ∈ Set.Ioc a b then f x else 0) x = 0 | null | false |
Std.Internal.List.maxKey! | Std.Data.Internal.List.Associative | {α : Type u} → {β : α → Type v} → [Ord α] → [Inhabited α] → List ((a : α) × β a) → α | Given a proof that the list is nonempty, returns the smallest key in an associative list. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.get_diff!._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | null | false |
ContinuousAlternatingMap.coe_restrictScalars | Mathlib.Topology.Algebra.Module.Alternating.Basic | ∀ (R : Type u_1) {M : Type u_2} {N : Type u_4} {ι : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : TopologicalSpace M] [inst_4 : AddCommMonoid N] [inst_5 : Module R N]
[inst_6 : TopologicalSpace N] {A : Type u_7} [inst_7 : Semiring A] [inst_8 : SMul R A] [inst_9 : Module A ... | null | true |
Lean.JsonRpc.Notification.mk.sizeOf_spec | Lean.Data.JsonRpc | ∀ {α : Type u} [inst : SizeOf α] (method : String) (param : α),
sizeOf { method := method, param := param } = 1 + sizeOf method + sizeOf param | null | true |
_private.Mathlib.LinearAlgebra.LinearPMap.0.LinearPMap.mem_graph_snd_inj'._proof_1_1 | Mathlib.LinearAlgebra.LinearPMap | ∀ {R : Type u_3} [inst : Ring R] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module R E] {F : Type u_1}
[inst_3 : AddCommGroup F] [inst_4 : Module R F] (f : E →ₗ.[R] F) {x y : E × F},
x ∈ f.graph → y ∈ f.graph → x.1 = y.1 → x.2 = y.2 | null | false |
FinBddDistLat.hom_ext_iff | Mathlib.Order.Category.FinBddDistLat | ∀ {X Y : FinBddDistLat} {f g : X ⟶ Y}, f = g ↔ FinBddDistLat.Hom.hom f = FinBddDistLat.Hom.hom g | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Diagonal.0.Matrix.ker_diagonal_toLin'._simp_1_2 | Mathlib.LinearAlgebra.Matrix.Diagonal | ∀ {R : Type u} {ι : Type x} [inst : Semiring R] {φ : ι → Type i} [inst_1 : (i : ι) → AddCommMonoid (φ i)]
[inst_2 : (i : ι) → Module R (φ i)], ⊥ = ⨅ i, (LinearMap.proj i).ker | null | false |
RCLike.continuous_re | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], Continuous ⇑RCLike.re | null | true |
MeasureTheory.StronglyMeasurable.add_iff_left | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {β : Type u_2} {f g : α → β} {mα : MeasurableSpace α} [inst : TopologicalSpace β]
[inst_1 : AddCommGroup β] [IsTopologicalAddGroup β],
MeasureTheory.StronglyMeasurable f → (MeasureTheory.StronglyMeasurable (g + f) ↔ MeasureTheory.StronglyMeasurable g) | null | true |
CategoryTheory.trifunctorComp₂₃₄FunctorObj | Mathlib.CategoryTheory.Functor.Quadrifunctor | {C₁ : Type u_1} →
{C₂ : Type u_2} →
{C₃ : Type u_3} →
{C₄ : Type u_4} →
{C₂₃₄ : Type u_5} →
{E : Type u_7} →
[inst : CategoryTheory.Category.{v_1, u_1} C₁] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] →
[inst_2 : CategoryTheory.Category.{v_3,... | Auxiliary definition for `trifunctorComp₂₃₄Functor`. | true |
_private.Lean.Elab.Tactic.Grind.Main.0.Lean.Elab.Tactic.elabGrindPattern.elabCnstrs | Lean.Elab.Tactic.Grind.Main | Array Lean.Expr →
Option (Lean.TSyntax `Lean.Parser.Command.grindPatternCnstrs) →
Lean.Elab.TermElabM (List Lean.Meta.Grind.EMatchTheoremConstraint) | null | true |
Nat.exists_eq_pow_of_pow_eq_pow | Mathlib.Data.Nat.Factorization.Basic | ∀ {a b m n : ℕ}, m ≠ 0 ∨ n ≠ 0 → a ^ m = b ^ n → ∃ c, a = c ^ (n / m.gcd n) ∧ b = c ^ (m / m.gcd n) | null | true |
CategoryTheory.Abelian.SpectralObject.δ_δ._auto_1 | Mathlib.Algebra.Homology.SpectralObject.Basic | Lean.Syntax | null | false |
SimpleGraph.Walk.length_mapLe | Mathlib.Combinatorics.SimpleGraph.Walk.Maps | ∀ {V : Type u} {G G' : SimpleGraph V} (h : G ≤ G') {u v : V} (p : G.Walk u v),
(SimpleGraph.Walk.mapLe h p).length = p.length | null | true |
_private.Mathlib.GroupTheory.Index.0.Subgroup.index_inf_le._simp_1_1 | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : Group G] (H : Subgroup G), H.index = H.relIndex ⊤ | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.exists_ne_and_degree_eq_one.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {V : Type u_1} {G : SimpleGraph V}
(motive : (∃ u v p, ∃ (_ : p.IsPath), ∀ (u' v' : V) (p' : G.Walk u' v'), p'.IsPath → p'.length ≤ p.length) → Prop)
(x : ∃ u v p, ∃ (_ : p.IsPath), ∀ (u' v' : V) (p' : G.Walk u' v'), p'.IsPath → p'.length ≤ p.length),
(∀ (u v : V) (p : G.Walk u v) (hp : p.IsPath)
(hmax : ... | null | false |
SeminormedCommRing.induced._proof_2 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : CommRing R] [inst_2 : SeminormedRing S]
[NonUnitalRingHomClass F R S] (f : F) (a b : R), ‖a * b‖ ≤ ‖a‖ * ‖b‖ | null | false |
_private.Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm.0.μ_limsup_le_one | Mathlib.Analysis.Normed.Unbundled.SmoothingSeminorm | ∀ {R : Type u_1} [inst : CommRing R] (μ : RingSeminorm R) {s : ℕ → ℕ},
(∀ (n : ℕ), s n ≤ n) →
∀ {x : R} {ψ : ℕ → ℕ},
Filter.Tendsto ((fun n => ↑(s n) / ↑n) ∘ ψ) Filter.atTop (nhds 0) →
Filter.limsup (fun n => μ x ^ (↑(s (ψ n)) * (1 / ↑(ψ n)))) Filter.atTop ≤ 1 | null | true |
CategoryTheory.Sieve.generate_mono | Mathlib.CategoryTheory.Sites.Sieves.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X : C}, Monotone CategoryTheory.Sieve.generate | null | true |
ConcaveOn.le_map_average | Mathlib.Analysis.Convex.Integral | ∀ {α : Type u_1} {E : Type u_2} {m0 : MeasurableSpace α} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[CompleteSpace E] {μ : MeasureTheory.Measure α} {s : Set E} {f : α → E} {g : E → ℝ} [MeasureTheory.IsFiniteMeasure μ]
[NeZero μ],
ConcaveOn ℝ s g →
ContinuousOn g s →
IsClosed s →
(∀... | **Jensen's inequality**: if a function `g : E → ℝ` is concave and continuous on a convex closed
set `s`, `μ` is a finite non-zero measure on `α`, and `f : α → E` is a function sending
`μ`-a.e. points to `s`, then the average value of `g ∘ f` is less than or equal to the value of `g`
at the average value of `f` provided... | true |
isMulFreimanIso_empty | Mathlib.Combinatorics.Additive.FreimanHom | ∀ {α : Type u_2} {β : Type u_3} [inst : CommMonoid α] [inst_1 : CommMonoid β] {f : α → β} {n : ℕ},
IsMulFreimanIso n ∅ ∅ f | null | true |
List.map_coe_finRange_eq_range | Batteries.Data.List.Lemmas | ∀ {n : ℕ}, List.map (fun x => ↑x) (List.finRange n) = List.range n | null | true |
_private.Init.Data.String.Decode.0.ByteArray.utf8DecodeChar?.utf8Size_assemble₄ | Init.Data.String.Decode | ∀ {w x y z : UInt8} {c : Char}, ByteArray.utf8DecodeChar?.assemble₄ w x y z = some c → c.utf8Size = 4 | null | true |
Std.Net.interfaceAddresses | Std.Net.Addr | IO (Array Std.Net.InterfaceAddress) | Gets address information about the network interfaces on the system, including disabled ones and
multiple addresses for each interface.
| true |
_private.Mathlib.Geometry.Manifold.Notation.0.Manifold.Elab.totalSpaceMk.match_3 | Mathlib.Geometry.Manifold.Notation | (motive : Lean.Expr → Sort u_1) →
(x : Lean.Expr) → ((V arg : Lean.Expr) → motive (V.app arg)) → ((tgt : Lean.Expr) → motive tgt) → motive x | null | false |
NNRat.smulDivisionSemiring | Mathlib.Algebra.Field.Defs | {K : Type u_1} → [DivisionSemiring K] → SMul ℚ≥0 K | null | true |
Std.TreeSet.Raw.mem_erase | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet.Raw α cmp} [Std.TransCmp cmp],
t.WF → ∀ {k a : α}, a ∈ t.erase k ↔ cmp k a ≠ Ordering.eq ∧ a ∈ t | null | true |
_private.Mathlib.Order.CountableSupClosed.0.countableSupClosure._proof_1 | Mathlib.Order.CountableSupClosed | ∀ {α : Type u_1} [inst : Preorder α] (s : Set α),
∀ x ∈ s, ∃ A, ∃ (_ : A ⊆ s) (_ : A.Nonempty) (_ : A.Countable), IsLUB A x | null | false |
Std.TreeMap.Raw.mem_map | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, t.WF → (k ∈ Std.TreeMap.Raw.map f t ↔ k ∈ t) | null | true |
ONote.opowAux2 | Mathlib.SetTheory.Ordinal.Notation | ONote → ONote × ℕ → ONote | Auxiliary definition to compute the ordinal notation for the ordinal exponentiation in `opow` | true |
CategoryTheory.ShortComplex.RightHomologyMapData.rightHomologyMap_comm | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} {φ : S₁ ⟶ S₂} {h₁ : S₁.RightHomologyData} {h₂ : S₂.RightHomologyData}
(γ : CategoryTheory.ShortComplex.RightHomologyMapData φ h₁ h₂) [inst_2 : S₁.HasRightHomolog... | null | true |
WittVector.ghostComponent_zero_verschiebungFun | Mathlib.RingTheory.WittVector.Verschiebung | ∀ {p : ℕ} {R : Type u_1} [inst : CommRing R] [hp : Fact (Nat.Prime p)] (x : WittVector p R),
(WittVector.ghostComponent 0) x.verschiebungFun = 0 | null | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.Basic.0.SimplexCategory.intervalEdge._proof_3 | Mathlib.AlgebraicTopology.SimplexCategory.Basic | ∀ {n : ℕ} (j l : ℕ), j + l ≤ n → j + l < n + 1 | null | false |
_private.Mathlib.GroupTheory.Coxeter.Length.0.CoxeterSystem.not_isReduced_alternatingWord._proof_1_1 | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (i i' : B),
cs.length (cs.wordProd (CoxeterSystem.alternatingWord i i' (M.M i i' + 1))) < M.M i i' + 1 →
¬cs.length (cs.wordProd (CoxeterSystem.alternatingWord i i' (M.M i i' + 1))) = M.M i i' + 1 | null | false |
Compactum.instTopologicalSpaceA._proof_1 | Mathlib.Topology.Category.Compactum | ∀ {X : Compactum} (x : Ultrafilter X.A), X.str x ∈ Set.univ → Set.univ ∈ (↑x).sets | null | false |
AddMonoidAlgebra.le_inf_support_pow | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : SemilatticeInf T] [inst_1 : OrderTop T] [inst_2 : Semiring R]
[inst_3 : AddMonoid A] [inst_4 : AddMonoid T] [AddLeftMono T] [AddRightMono T] {degt : A → T},
0 ≤ degt 0 →
(∀ (a b : A), degt a + degt b ≤ degt (a + b)) →
∀ (n : ℕ) (f : AddMonoidAlgebra R... | null | true |
Std.Do.SPred.not_cons | Std.Do.SPred.SPred | ∀ {σs : List (Type u)} {σ : Type u} {s : σ} {P : Std.Do.SPred (σ :: σs)}, spred(¬P) s = spred(¬P s) | null | true |
mersenne_le_mersenne._simp_1 | Mathlib.NumberTheory.LucasLehmer | ∀ {p q : ℕ}, (mersenne p ≤ mersenne q) = (p ≤ q) | null | false |
MeasureTheory.exists_mem_forall_mem_nhdsWithin_pos_measure | Mathlib.MeasureTheory.OuterMeasure.Basic | ∀ {α : Type u_1} {F : Type u_3} [inst : FunLike F (Set α) ENNReal] [MeasureTheory.OuterMeasureClass F α] {μ : F}
[inst_2 : TopologicalSpace α] [SecondCountableTopology α] {s : Set α},
μ s ≠ 0 → ∃ x ∈ s, ∀ t ∈ nhdsWithin x s, 0 < μ t | If `m s ≠ 0`, then for some point `x ∈ s` and any `t ∈ 𝓝[s] x` we have `0 < m t`. | true |
NumberField.Units.dirichletUnitTheorem.logSpace.congr_simp | Mathlib.NumberTheory.NumberField.Units.Regulator | ∀ (K : Type u_1) [inst : Field K] [inst_1 : NumberField K],
NumberField.Units.dirichletUnitTheorem.logSpace K = NumberField.Units.dirichletUnitTheorem.logSpace K | null | true |
CategoryTheory.LocalizerMorphism.homMap.eq_1 | Mathlib.CategoryTheory.Localization.HomEquiv | ∀ {C₁ : Type u_2} {C₂ : Type u_3} {D₁ : Type u_5} {D₂ : Type u_6} [inst : CategoryTheory.Category.{v_2, u_2} C₁]
[inst_1 : CategoryTheory.Category.{v_3, u_3} C₂] [inst_2 : CategoryTheory.Category.{v_5, u_5} D₁]
[inst_3 : CategoryTheory.Category.{v_6, u_6} D₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : Catego... | null | true |
FirstOrder.Language.BoundedFormula.IsQF.toPrenexImpRight | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {φ ψ : L.BoundedFormula α n}, ψ.IsQF → φ.toPrenexImpRight ψ = φ.imp ψ | null | true |
padicNorm.sum_lt | Mathlib.NumberTheory.Padics.PadicNorm | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {α : Type u_1} {F : α → ℚ} {t : ℚ} {s : Finset α},
s.Nonempty → (∀ i ∈ s, padicNorm p (F i) < t) → padicNorm p (∑ i ∈ s, F i) < t | null | true |
GroupSeminorm.instAddCommMonoid._proof_6 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : Group E] (a b : GroupSeminorm E), a + b = b + a | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.transformObjPrecomposeObjSquare_iso_inv_app_snd_app | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} A]
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] [inst_2 : CategoryTheory.Category.{v₃, u₃} C]
{F : CategoryTheory.Functor A B} {G : CategoryTheory.Functor C B} {A₁ : Type u₄} {B₁ : Type u₅} {C₁ : Type u₆}
[inst_3 : CategoryTheor... | null | true |
Matroid.closure_loops_union_eq | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} (M : Matroid α) (X : Set α), M.closure (M.loops ∪ X) = M.closure X | null | true |
CategoryTheory.PreZeroHypercover.inv_hom_h₀ | Mathlib.CategoryTheory.Sites.Hypercover.Zero | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {S : C} {E F : CategoryTheory.PreZeroHypercover S} (e : E ≅ F)
(i : F.I₀), CategoryTheory.CategoryStruct.comp (e.inv.h₀ i) (e.hom.h₀ (e.inv.s₀ i)) = CategoryTheory.eqToHom ⋯ | null | true |
AddCommGrpCat.imageIsoRange._proof_1 | Mathlib.Algebra.Category.Grp.Images | ∀ {G H : AddCommGrpCat} (f : G ⟶ H), CategoryTheory.Limits.HasImage f | null | false |
Lean.Meta.GeneralizeTelescope.generalizeTelescopeAux | Lean.Meta.GeneralizeTelescope | {α : Type} →
(Array Lean.Expr → Lean.MetaM α) → Array Lean.Meta.GeneralizeTelescope.Entry → ℕ → Array Lean.Expr → Lean.MetaM α | null | true |
Array.Matcher.Iterator.recOn | Batteries.Data.Array.Match | {σ : Type u_1} →
{n : Type u_1 → Type u_2} →
{α : Type u_1} →
[inst : BEq α] →
{m : Array.Matcher α} →
[inst_1 : Std.Iterator σ n α] →
{motive : Array.Matcher.Iterator σ n α m → Sort u} →
(t : Array.Matcher.Iterator σ n α m) →
((inner : Std.IterM n... | null | false |
EReal.tendsto_toReal | Mathlib.Topology.Instances.EReal.Lemmas | ∀ {a : EReal}, a ≠ ⊤ → a ≠ ⊥ → Filter.Tendsto EReal.toReal (nhds a) (nhds a.toReal) | null | true |
UniformContinuous.prodMk_right | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} {β : Type ub} {γ : Type uc} [inst : UniformSpace α] [inst_1 : UniformSpace β] [inst_2 : UniformSpace γ]
{f : α × β → γ}, UniformContinuous f → ∀ (a : α), UniformContinuous fun b => f (a, b) | null | true |
FinEnum.pempty._proof_1 | Mathlib.Data.FinEnum | ∀ (x : PEmpty.{u_1 + 1}), x ∈ [] | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.