name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Acc.ndrec | Init.WF | {α : Sort u2} →
{r : α → α → Prop} →
{C : α → Sort u1} →
((x : α) → (∀ (y : α), r y x → Acc r y) → ((y : α) → r y x → C y) → C x) → {a : α} → Acc r a → C a | null | true |
ContDiffOn.pow | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {n : WithTop ℕ∞} {𝔸 : Type u_3} [inst_3 : NormedRing 𝔸]
[inst_4 : NormedAlgebra 𝕜 𝔸] {f : E → 𝔸}, ContDiffOn 𝕜 n f s → ∀ (m : ℕ), ContDiffOn 𝕜 n (fun y => f y ^ m) s | null | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.MkNameM | Lean.Elab.DeclNameGen | Type → Type | Monad for name generation.
| true |
Std.DTreeMap.Const.get!_modify_self | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {β : Type v} {t : Std.DTreeMap α (fun x => β) cmp} {k : α}
[inst : Inhabited β] {f : β → β},
Std.DTreeMap.Const.get! (Std.DTreeMap.Const.modify t k f) k = (Option.map f (Std.DTreeMap.Const.get? t k)).get! | null | true |
Prod.instCoheytingAlgebra._proof_2 | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : CoheytingAlgebra α] [inst_1 : CoheytingAlgebra β] (a : α × β), ⊤ \ a = ￢a | null | false |
SSet.StrictSegal.ofIsStrictSegal._proof_2 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ (X : SSet) [inst : X.IsStrictSegal] (n : ℕ), (Equiv.ofBijective (X.spine n) ⋯).invFun ∘ X.spine n = id | null | false |
Aesop.GoalOrigin | Aesop.Tree.Data | Type | A goal `G` can be added to the tree for three reasons:
1. `G` was produced by its parent rule as a subgoal. This is the most common
reason.
2. `G` was copied because it contains some metavariables which were assigned by
its parent rule. In this case, we record goal of which `G` is a copy. We also
record the r... | true |
CoalgHom.mk._flat_ctor | Mathlib.RingTheory.Coalgebra.Hom | {R : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid A] →
[inst_2 : Module R A] →
[inst_3 : AddCommMonoid B] →
[inst_4 : Module R B] →
[inst_5 : CoalgebraStruct R A] →
[inst_6 : Coal... | null | false |
vectorSpan_mono | 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]
[inst_3 : AddTorsor V P] {s₁ s₂ : Set P}, s₁ ⊆ s₂ → vectorSpan k s₁ ≤ vectorSpan k s₂ | `vectorSpan` is monotone. | true |
Submodule.span_smul | Mathlib.LinearAlgebra.Span.Basic | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_8}
[inst_3 : Monoid α] [inst_4 : DistribMulAction α M] [inst_5 : SMulCommClass α R M] (a : α) (s : Set M),
Submodule.span R (a • s) = a • Submodule.span R s | null | true |
_private.Mathlib.Probability.Distributions.Gaussian.Real.0.ProbabilityTheory.complexMGF_id_gaussianReal._simp_1_5 | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False | null | false |
Lean.Meta.Grind.InjectiveInfo.inv? | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.InjectiveInfo → Option (Lean.Expr × Lean.Expr) | Inverse function and a proof that `∀ a, inv (f a) = a`
**Note**: The following two fields are `none` if no `f`-application has been found yet.
| true |
BoxIntegral.Prepartition.mk.sizeOf_spec | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {ι : Type u_1} {I : BoxIntegral.Box ι} [inst : SizeOf ι] (boxes : Finset (BoxIntegral.Box ι))
(le_of_mem' : ∀ J ∈ boxes, J ≤ I)
(pairwiseDisjoint : (↑boxes).Pairwise (Function.onFun Disjoint BoxIntegral.Box.toSet)),
sizeOf { boxes := boxes, le_of_mem' := le_of_mem', pairwiseDisjoint := pairwiseDisjoint } = 1 + ... | null | true |
Lean.Name.str._impl | Init.Prelude | UInt64 → Lean.Name → String → Lean.Name._impl | null | false |
conformalAt_id | Mathlib.Analysis.Calculus.Conformal.NormedSpace | ∀ {X : Type u_1} [inst : NormedAddCommGroup X] [inst_1 : NormedSpace ℝ X] (x : X), ConformalAt id x | null | true |
_private.Mathlib.Tactic.TacticAnalysis.0.Mathlib.TacticAnalysis.runPass.match_5 | Mathlib.Tactic.TacticAnalysis | (config : Mathlib.TacticAnalysis.ComplexConfig) →
(motive : Mathlib.TacticAnalysis.TriggerCondition config.ctx → Sort u_1) →
(x : Mathlib.TacticAnalysis.TriggerCondition config.ctx) →
((ctx : config.ctx) → motive (Mathlib.TacticAnalysis.TriggerCondition.accept ctx)) →
((x : Mathlib.TacticAnalysis.Tr... | null | false |
Aesop.RuleResult.isSuccessful | Aesop.Search.Expansion | Aesop.RuleResult → Bool | null | true |
_private.Mathlib.Data.List.Count.0.List.countP_erase._proof_1_2 | Mathlib.Data.List.Count | ∀ {α : Type u_1} (p : α → Bool) (l : List α), 1 ≤ (List.filter p l).length → 0 < (List.findIdxs p l).length | null | false |
_private.Mathlib.CategoryTheory.Triangulated.Opposite.OpOp.0.CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._proof_3 | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ (n m : ℤ), autoParam (n + m = 0) CategoryTheory.Pretriangulated.commShiftIso_opOp_hom_app._auto_1 → m + n = 0 | null | false |
MulChar.instMulCharClass | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'],
MulCharClass (MulChar R R') R R' | null | true |
_private.Mathlib.GroupTheory.Descent.0.Group.fg_of_descent._simp_1_4 | Mathlib.GroupTheory.Descent | ∀ {M₀ : Type u_1} [inst : Mul M₀] [inst_1 : Zero M₀] [NoZeroDivisors M₀] {a b : M₀}, a ≠ 0 → b ≠ 0 → (a * b = 0) = False | null | false |
Valuation.val_le_one_or_val_inv_lt_one | Mathlib.RingTheory.Valuation.Basic | ∀ {K : Type u_1} [inst : DivisionRing K] {Γ₀ : Type u_4} [inst_1 : LinearOrderedCommGroupWithZero Γ₀]
(v : Valuation K Γ₀) (x : K), v x ≤ 1 ∨ v x⁻¹ < 1 | null | true |
Lean.Grind.IntInterval.lo?.eq_4 | Init.Grind.ToIntLemmas | Lean.Grind.IntInterval.ii.lo? = none | null | true |
AddAction.stabilizer.eq_1 | Mathlib.GroupTheory.GroupAction.Defs | ∀ (G : Type u_1) {α : Type u_2} [inst : AddGroup G] [inst_1 : AddAction G α] (a : α),
AddAction.stabilizer G a = { toAddSubmonoid := AddAction.stabilizerAddSubmonoid G a, neg_mem' := ⋯ } | null | true |
ContinuousMultilinearMap.nnnorm_constOfIsEmpty | Mathlib.Analysis.Normed.Module.Multilinear.Basic | ∀ (𝕜 : Type u) {ι : Type v} (E : ι → Type wE) {G : Type wG} [inst : NontriviallyNormedField 𝕜]
[inst_1 : (i : ι) → SeminormedAddCommGroup (E i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (E i)]
[inst_3 : SeminormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G] [inst_5 : Fintype ι] [inst_6 : IsEmpty ι] (x : G),
‖Continuou... | null | true |
groupCohomology.Hilbert90.aux.eq_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Hilbert90 | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : FiniteDimensional K L] (f : Gal(L/K) → Lˣ),
groupCohomology.Hilbert90.aux f =
(Finsupp.linearCombination L fun φ => ⇑φ) (Finsupp.equivFunOnFinite.symm fun φ => ↑(f φ)) | null | true |
Pi.seminormedRing._proof_7 | Mathlib.Analysis.Normed.Ring.Lemmas | ∀ {ι : Type u_1} {R : ι → Type u_2} [inst : Fintype ι] [inst_1 : (i : ι) → SeminormedRing (R i)] (a : (i : ι) → R i),
0 * a = 0 | null | false |
FractionalIdeal.count._proof_2 | Mathlib.RingTheory.DedekindDomain.Factorization | ∀ {R : Type u_1} [inst : CommRing R] (K : Type u_2) [inst_1 : Field K] [inst_2 : Algebra R K]
[inst_3 : IsFractionRing R K] [inst_4 : IsDedekindDomain R] (I : FractionalIdeal (nonZeroDivisors R) K),
∃ aI,
Classical.choose ⋯ ≠ 0 ∧
I = FractionalIdeal.spanSingleton (nonZeroDivisors R) ((algebraMap R K) (Cla... | null | false |
Nat.Ico_zero_eq_range | Mathlib.Order.Interval.Finset.Nat | ∀ (a : ℕ), Finset.Ico 0 a = Finset.range a | null | true |
Polynomial.Monic.degree_pos | Mathlib.Algebra.Polynomial.Degree.Operations | ∀ {R : Type u} [inst : CommSemiring R] {p : Polynomial R}, p.Monic → (0 < p.degree ↔ p ≠ 1) | null | true |
SeparationQuotient.instDistrib._proof_1 | Mathlib.Topology.Algebra.SeparationQuotient.Basic | ∀ {R : Type u_1} [inst : TopologicalSpace R] [inst_1 : Distrib R] [inst_2 : ContinuousMul R] [inst_3 : ContinuousAdd R]
(a b c : SeparationQuotient R), a * (b + c) = a * b + a * c | null | false |
_private.Lean.Meta.Tactic.Grind.Propagate.0.Lean.Meta.Grind.propagateDIte._regBuiltin.Lean.Meta.Grind.propagateDIte.declare_1._@.Lean.Meta.Tactic.Grind.Propagate.3737351488._hygCtx._hyg.8 | Lean.Meta.Tactic.Grind.Propagate | IO Unit | null | false |
_private.Mathlib.Data.List.TakeDrop.0.List.takeD_eq_take.match_1_1 | Mathlib.Data.List.TakeDrop | ∀ {α : Type u_1} (motive : (x : ℕ) → (x_1 : List α) → α → x ≤ x_1.length → Prop) (x : ℕ) (x_1 : List α) (x_2 : α)
(x_3 : x ≤ x_1.length),
(∀ (x : List α) (x_4 : α) (x_5 : 0 ≤ x.length), motive 0 x x_4 x_5) →
(∀ (n : ℕ) (head : α) (tail : List α) (a : α) (h : n + 1 ≤ (head :: tail).length),
motive n.succ... | null | false |
Lean.instInhabitedTheoremVal | Lean.Declaration | Inhabited Lean.TheoremVal | null | true |
t1Space_iff_specializes_imp_eq | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X], T1Space X ↔ ∀ ⦃x y : X⦄, x ⤳ y → x = y | null | true |
Submodule.IsOrtho.le | Mathlib.Analysis.InnerProductSpace.Orthogonal | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{U V : Submodule 𝕜 E}, U ⟂ V → U ≤ Vᗮ | null | true |
AdicCompletion.of_injective | Mathlib.RingTheory.AdicCompletion.Basic | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R) (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[IsHausdorff I M], Function.Injective ⇑(AdicCompletion.of I M) | null | true |
Vector.finIdxOf? | Init.Data.Vector.Basic | {α : Type u_1} → {n : ℕ} → [BEq α] → Vector α n → α → Option (Fin n) | Finds the first index of a given value in a vector using `==` for comparison. Returns `none` if the
no element of the index matches the given value.
| true |
_private.Mathlib.Data.WSeq.Basic.0.Stream'.WSeq.flatten.match_1.splitter | Mathlib.Data.WSeq.Basic | {α : Type u_1} →
(motive : Stream'.WSeq α ⊕ Computation (Stream'.WSeq α) → Sort u_2) →
(x : Stream'.WSeq α ⊕ Computation (Stream'.WSeq α)) →
((s : Stream'.WSeq α) → motive (Sum.inl s)) →
((c' : Computation (Stream'.WSeq α)) → motive (Sum.inr c')) → motive x | null | true |
MeasureTheory.Measure.pi | Mathlib.MeasureTheory.Constructions.Pi | {ι : Type u_4} →
{α : ι → Type u_5} →
[Fintype ι] →
[inst : (i : ι) → MeasurableSpace (α i)] →
((i : ι) → MeasureTheory.Measure (α i)) → MeasureTheory.Measure ((i : ι) → α i) | `Measure.pi μ` is the finite product of the measures `{μ i | i : ι}`.
It is defined to be measure corresponding to `MeasureTheory.OuterMeasure.pi`. | true |
MonoidWithZeroHom | Mathlib.Algebra.GroupWithZero.Hom | (α : Type u_7) → (β : Type u_8) → [MulZeroOneClass α] → [MulZeroOneClass β] → Type (max u_7 u_8) | `α →*₀ β` is the type of functions `α → β` that preserve
the `MonoidWithZero` structure.
`MonoidWithZeroHom` is also used for group homomorphisms.
When possible, instead of parametrizing results over `(f : α →*₀ β)`,
you should parametrize over `(F : Type*) [MonoidWithZeroHomClass F α β] (f : F)`.
When you extend th... | true |
_private.Mathlib.GroupTheory.MonoidLocalization.Basic.0.Submonoid.LocalizationMap.isCancelMul.match_1_2 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : CommMonoid M] {S : Submonoid M} [inst_1 : CommMonoid N]
(f : S.LocalizationMap N) (n : N) (motive : (∃ x, n * f ↑x.2 = f x.1) → Prop) (x : ∃ x, n * f ↑x.2 = f x.1),
(∀ (ms : M × ↥S) (eq : n * f ↑ms.2 = f ms.1), motive ⋯) → motive x | null | false |
CategoryTheory.Limits.HasBinaryProduct | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | {C : Type u} → [CategoryTheory.Category.{v, u} C] → C → C → Prop | An abbreviation for `HasLimit (pair X Y)`. | true |
_private.Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise.0.SubMulAction.instMulOneClass._simp_1 | Mathlib.GroupTheory.GroupAction.SubMulAction.Pointwise | ∀ {R : Type u_1} {M : Type u_2} [inst : Monoid R] [inst_1 : MulAction R M] [inst_2 : Mul M]
[inst_3 : IsScalarTower R M M] {p q : SubMulAction R M} {x : M}, (x ∈ p * q) = ∃ y ∈ p, ∃ z ∈ q, y * z = x | null | false |
Array.isEmpty.eq_1 | Init.Data.Array.DecidableEq | ∀ {α : Type u} (xs : Array α), xs.isEmpty = decide (xs.size = 0) | null | true |
Std.instLawfulOrderLeftLeaningMaxOfIsLinearOrderOfLawfulOrderSup | Init.Data.Order.Lemmas | ∀ {α : Type u} [inst : LE α] [inst_1 : Max α] [Std.IsLinearOrder α] [Std.LawfulOrderSup α],
Std.LawfulOrderLeftLeaningMax α | null | true |
Std.DTreeMap.Internal.Impl.Const.get!_insertIfNew! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α]
[inst : Inhabited β],
t.WF →
∀ {k a : α} {v : β},
Std.DTreeMap.Internal.Impl.Const.get! (Std.DTreeMap.Internal.Impl.insertIfNew! k v t) a =
if compare k a = Ordering.eq ∧ k ∉ t then v else ... | null | true |
Std.IterM.filter.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β : Type w} {m : Type w → Type w'} [inst : Std.Iterator α m β] [inst_1 : Monad m] (f : β → Bool)
(it : Std.IterM m β), Std.IterM.filter f it = Std.IterM.filterMap (fun b => if f b = true then some b else none) it | null | true |
TrivSqZeroExt.snd | Mathlib.Algebra.TrivSqZeroExt.Basic | {R : Type u} → {M : Type v} → TrivSqZeroExt R M → M | The canonical projection `TrivSqZeroExt R M → M`. | true |
CauSeq.equiv | Mathlib.Algebra.Order.CauSeq.Basic | {α : Type u_1} →
{β : Type u_2} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
[inst_3 : Ring β] → {abv : β → α} → [IsAbsoluteValue abv] → Setoid (CauSeq β abv) | null | true |
add_lt_add_iff_right_of_ne_top | Mathlib.Algebra.Order.AddGroupWithTop | ∀ {α : Type u_2} [inst : LinearOrderedAddCommMonoidWithTop α] {a b c : α}, a ≠ ⊤ → (a + b < a + c ↔ b < c) | null | true |
Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr.mkBVConst | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.ReifiedBVExpr | {w : ℕ} → BitVec w → Lean.Elab.Tactic.BVDecide.Frontend.M Lean.Elab.Tactic.BVDecide.Frontend.ReifiedBVExpr | Build a reified version of the constant `val`.
| true |
ContDiffOn.continuousOn_fderivWithin_apply | Mathlib.Analysis.Calculus.ContDiff.Comp | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E} {f : E → F}
{n : WithTop ℕ∞},
ContDiffOn 𝕜 n f s → UniqueDiffOn 𝕜 s → 1 ≤ n → ContinuousOn (fun ... | If a function is at least `C^1`, its bundled derivative (mapping `(x, v)` to `Df(x) v`) is
continuous. | true |
_private.Mathlib.Data.Finset.Basic.0.Finset.erase_cons_of_ne._proof_1_2 | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {a b : α} {s : Finset α} (ha : a ∉ s),
a ≠ b → (Finset.cons a s ha).erase b = Finset.cons a (s.erase b) ⋯ | null | false |
MultiplierAlgebra.«_aux_Mathlib_Analysis_CStarAlgebra_Multiplier___macroRules_MultiplierAlgebra_term𝓜(_,_)_1» | Mathlib.Analysis.CStarAlgebra.Multiplier | Lean.Macro | null | false |
IsIntegral.mem_range_algebraMap_of_minpoly_splits | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u_1} {K : Type u_2} {L : Type u_3} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra R K] {x : L} [inst_4 : Algebra R L] [inst_5 : Algebra K L] [IsScalarTower R K L],
IsIntegral R x → (Polynomial.map (algebraMap R K) (minpoly R x)).Splits → x ∈ (algebraMap K L).range | null | true |
iteratedFDerivWithin_insert | Mathlib.Analysis.Calculus.ContDiff.FTaylorSeries | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {s : Set E}
{f : E → F} {x : E} {n : ℕ} {y : E}, iteratedFDerivWithin 𝕜 n f (insert x s) y = iteratedFDerivWithin �... | null | true |
Finite.ciInf_le_of_le | Mathlib.Data.Fintype.Order | ∀ {α : Type u_1} {ι : Type u_2} [Finite ι] [inst : ConditionallyCompleteLattice α] {a : α} {f : ι → α} (c : ι),
f c ≤ a → iInf f ≤ a | null | true |
NoBotOrder.casesOn | Mathlib.Order.Max | {α : Type u_3} →
[inst : LE α] →
{motive : NoBotOrder α → Sort u} →
(t : NoBotOrder α) → ((exists_not_ge : ∀ (a : α), ∃ b, ¬a ≤ b) → motive ⋯) → motive t | null | false |
AddActionHom.inverse._proof_2 | Mathlib.GroupTheory.GroupAction.Hom | ∀ {M : Type u_2} {X : Type u_1} [inst : VAdd M X] {Y₁ : Type u_3} [inst_1 : VAdd M Y₁] (f : X →ₑ[id] Y₁) (g : Y₁ → X)
(m : M) (x : Y₁), g (m +ᵥ f (g x)) = g (f (m +ᵥ g x)) | null | false |
Lean.Meta.Simp.debug.simp.check.have | Lean.Meta.Tactic.Simp.Main | Lean.Option Bool | null | true |
_private.Aesop.Script.Step.0.Aesop.Script.LazyStep.runFirstSuccessfulTacticBuilder.tryTacticBuilder.match_4 | Aesop.Script.Step | (motive : Option (Lean.Meta.SavedState × List Lean.MVarId) → Sort u_1) →
(tacticResult : Option (Lean.Meta.SavedState × List Lean.MVarId)) →
((actualPostState : Lean.Meta.SavedState) →
(actualPostGoals : List Lean.MVarId) → motive (some (actualPostState, actualPostGoals))) →
((x : Option (Lean.Meta.... | null | false |
TendstoLocallyUniformlyOn.fun_sub | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : AddGroup α] [IsUniformAddGroup α] {ι : Type u_3} {X : Type u_4}
[inst_3 : TopologicalSpace X] {F G : ι → X → α} {f g : X → α} {s : Set X} {l : Filter ι},
TendstoLocallyUniformlyOn F f l s →
TendstoLocallyUniformlyOn G g l s →
TendstoLocallyUniformlyOn (fu... | Eta-expanded form of `TendstoLocallyUniformlyOn.sub` | true |
Lex.instMulZeroOneClass | Mathlib.Algebra.Order.GroupWithZero.Synonym | {α : Type u_1} → [MulZeroOneClass α] → MulZeroOneClass (Lex α) | null | true |
_private.Mathlib.Analysis.BoxIntegral.Partition.Basic.0.BoxIntegral.Prepartition.injOn_setOf_mem_Icc_setOf_lower_eq._simp_1_2 | Mathlib.Analysis.BoxIntegral.Partition.Basic | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
_private.Mathlib.Order.Cover.0.LT.lt.exists_disjoint_Iio_Ioi._proof_1_1 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : LinearOrder α] {a b : α}, a < b → ∃ a', a < a' ∧ ∃ b' < b, ∀ x < a', ∀ (y : α), b' < y → x < y | null | false |
String.Slice.getUTF8Byte.eq_1 | Init.Data.String.Basic | ∀ (s : String.Slice) (p : String.Pos.Raw) (h : p < s.rawEndPos),
s.getUTF8Byte p h = s.str.getUTF8Byte (p.offsetBy s.startInclusive.offset) ⋯ | null | true |
_private.Init.Data.Int.Gcd.0.Int.gcd_eq_natAbs_right_iff_dvd._simp_1_1 | Init.Data.Int.Gcd | ∀ {n m : ℕ}, (n.gcd m = m) = (m ∣ n) | null | false |
AlgHom.convOne_def | Mathlib.RingTheory.Bialgebra.Convolution | ∀ {R : Type u_1} {A : Type u_2} {C : Type u_4} [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Semiring C]
[inst_3 : Bialgebra R C] [inst_4 : Algebra R A],
1 = WithConv.toConv ((Algebra.ofId R A).comp (Bialgebra.counitAlgHom R C)) | null | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_451 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Positive.0.ContinuousLinearMap.isPositive_iff'._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Positive | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : CompleteSpace E] {A : E →L[𝕜] E}, IsSelfAdjoint A = (↑A).IsSymmetric | null | false |
IsRealClosed.rec | Mathlib.FieldTheory.IsRealClosed.Basic | {R : Type u_1} →
[inst : Field R] →
{motive : IsRealClosed R → Sort u} →
([toIsSemireal : IsSemireal R] →
(isSquare_or_isSquare_neg : ∀ (x : R), IsSquare x ∨ IsSquare (-x)) →
(exists_isRoot_of_odd_natDegree : ∀ {f : Polynomial R}, Odd f.natDegree → ∃ x, f.IsRoot x) → motive ⋯) →
... | null | false |
Lean.Lsp.FoldingRangeKind.ctorElim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.FoldingRangeKind → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Lsp.FoldingRangeKind) → ctorIdx = t.ctorIdx → Lean.Lsp.FoldingRangeKind.ctorElimType ctorIdx → motive t | null | false |
Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries.recOn | Mathlib.Tactic.Translate.UnfoldBoundary | {motive : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries → Sort u} →
(t : Mathlib.Tactic.UnfoldBoundary.UnfoldBoundaries) →
((unfolds : Lean.NameMap Lean.Meta.SimpTheorem) →
(casts : Lean.NameMap (Lean.Name × Lean.Name)) →
(insertionFuns : Lean.NameSet) →
motive { unfolds := unfolds,... | null | false |
Ordnode.Bounded._sparseCasesOn_1.else_eq | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u} {motive : Option α → Sort u_1} (t : Option α) (some : (val : α) → motive (some val))
(«else» : Nat.hasNotBit 2 t.ctorIdx → motive t) (h : Nat.hasNotBit 2 t.ctorIdx),
Ordnode.Bounded._sparseCasesOn_1 t some «else» = «else» h | null | false |
Std.Internal.List.Const.getValue_alterKey_self._proof_1 | Std.Data.Internal.List.Associative | ∀ {α : Type u_2} [inst : BEq α] {β : Type u_1} [EquivBEq α] (k : α) (f : Option β → Option β) (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.containsKey k (Std.Internal.List.Const.alterKey k f l) = true →
(f (Std.Internal.List.getValue? k l)).isSome = true | null | false |
ContinuousMap.HomotopicRel.symm | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {S : Set X} ⦃f g : C(X, Y)⦄,
f.HomotopicRel g S → g.HomotopicRel f S | null | true |
_private.Init.Data.Array.Basic.0.Array.allDiffAux._proof_1 | Init.Data.Array.Basic | ∀ {α : Type u_1} (as : Array α), ∀ i < as.size, InvImage (fun x1 x2 => x1 < x2) (fun x => as.size - x) (i + 1) i | null | false |
_private.Init.Data.Range.Polymorphic.Instances.0.Std.Rxo.LawfulHasSize.of_closed._simp_6 | Init.Data.Range.Polymorphic.Instances | ∀ {α : Type u} [inst : LE α] [inst_1 : Std.PRange.UpwardEnumerable α] [inst_2 : Std.Rxc.HasSize α]
[Std.Rxc.LawfulHasSize α] {lo hi : α}, (0 < Std.Rxc.HasSize.size lo hi) = (lo ≤ hi) | null | false |
CategoryTheory.StrictlyUnitaryLaxFunctorCore._proof_2 | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ (B : Type u_5) [inst : CategoryTheory.Bicategory B] (C : Type u_2) [inst_1 : CategoryTheory.Bicategory C]
(obj : B → C) (map : {X Y : B} → (X ⟶ Y) → (obj X ⟶ obj Y)),
(∀ (X : B), map (CategoryTheory.CategoryStruct.id X) = CategoryTheory.CategoryStruct.id (obj X)) →
∀ {a b : B} (f : a ⟶ b),
CategoryTheor... | null | false |
Polynomial.roots_map_of_injective_of_card_eq_natDegree | Mathlib.Algebra.Polynomial.Roots | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : IsDomain A] [inst_3 : IsDomain B]
{p : Polynomial A} {f : A →+* B},
Function.Injective ⇑f → p.roots.card = p.natDegree → Multiset.map (⇑f) p.roots = (Polynomial.map f p).roots | null | true |
Unitization.mk_toProd | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} (x : Unitization R A), Unitization.mk x.toProd = x | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks.0.SimpleGraph.Walk.isSubwalk_iff_darts_isInfix._proof_1_21 | Mathlib.Combinatorics.SimpleGraph.Walk.Subwalks | ∀ {V : Type u_1} {G : SimpleGraph V} {u v u' v' : V} {p₁ : G.Walk u v} {p₂ : G.Walk u' v'} (k : ℕ)
(hk : p₁.support.length + k ≤ p₂.support.length),
(∀ (i : ℕ) (h : i < p₁.support.length), p₂.support[i + k]? = some p₁.support[i]) →
∀ (i : ℕ) (hi : i < p₁.darts.length), p₂.darts[i + k].toProd.1 = p₁.darts[i].toP... | null | false |
CoxeterSystem.exists_reduced_word | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} (cs : CoxeterSystem M W) (w : W),
∃ ω, cs.IsReduced ω ∧ w = cs.wordProd ω | **Alias** of `CoxeterSystem.exists_isReduced`. | true |
Int8.ofUInt8.sizeOf_spec | Init.Data.SInt.Basic | ∀ (toUInt8 : UInt8), sizeOf { toUInt8 := toUInt8 } = 1 + sizeOf toUInt8 | null | true |
Submodule.spanRank_toENat_eq_iInf_finset_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.toENat p.spanRank = ⨅ s, ↑(↑s).card | null | true |
ProofWidgets.Component.mk.sizeOf_spec | ProofWidgets.Component.Basic | ∀ {Props : Type} [inst : SizeOf Props] (toModule : Lean.Widget.Module) («export» : String),
sizeOf { toModule := toModule, «export» := «export» } = 1 + sizeOf toModule + sizeOf «export» | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.0._regBuiltin.String.reducePush.declare_28._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.String.1574800046._hygCtx._hyg.14 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.String | IO Unit | null | false |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars.0.Lean.Meta.Grind.Arith.Cutsat.updateVarCoeff | Lean.Meta.Tactic.Grind.Arith.Cutsat.ReorderVars | ℤ → Int.Linear.Var → Lean.Meta.Grind.Arith.Cutsat.CollectM✝ Unit | null | true |
Int64.ofNat_add | Init.Data.SInt.Lemmas | ∀ (a b : ℕ), Int64.ofNat (a + b) = Int64.ofNat a + Int64.ofNat b | null | true |
Std.Http.URI.Builder.mk.noConfusion | Std.Http.Data.URI.Basic | {P : Sort u} →
{scheme : Option Std.Http.URI.Scheme} →
{userInfo : Option Std.Http.URI.UserInfo} →
{host : Option Std.Http.URI.Host} →
{port : Std.Http.URI.Port} →
{pathSegments : Array String} →
{query : Array (String × Option String)} →
{fragment : Option String... | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Artanh.0.Real.artanh_neg._proof_1_1 | Mathlib.Analysis.SpecialFunctions.Artanh | ∀ {x : ℝ}, x ∈ Set.Ioo (-1) 0 → x ∈ Set.Ioo (-1) 1 | null | false |
Matrix.IsAdjMatrix.apply_diag | Mathlib.Combinatorics.SimpleGraph.AdjMatrix | ∀ {α : Type u_1} {V : Type u_2} [inst : Zero α] [inst_1 : One α] {A : Matrix V V α},
A.IsAdjMatrix → ∀ (i : V), A i i = 0 | null | true |
IsSolvable | Mathlib.GroupTheory.Solvable | (G : Type u_1) → [Group G] → Prop | A group `G` is solvable if its derived series is eventually trivial. We use this definition
because it's the most convenient one to work with. | true |
AddSubgroup.relIndex_eq_two_iff | Mathlib.GroupTheory.Index | ∀ {G : Type u_1} [inst : AddGroup G] {H K : AddSubgroup G}, H.relIndex K = 2 ↔ ∃ a ∈ K, ∀ b ∈ K, Xor (b + a ∈ H) (b ∈ H) | Relative version of `AddSubgroup.index_eq_two_iff`. | true |
ZMod.valMinAbs_natCast_eq_self._simp_1 | Mathlib.Data.ZMod.ValMinAbs | ∀ {n a : ℕ} [NeZero n], ((↑a).valMinAbs = ↑a) = (a ≤ n / 2) | null | false |
OpenSubgroup.instPartialOrder.eq_1 | Mathlib.Topology.Algebra.OpenSubgroup | ∀ {G : Type u_1} [inst : Group G] [inst_1 : TopologicalSpace G],
OpenSubgroup.instPartialOrder = PartialOrder.ofSetLike (OpenSubgroup G) G | null | true |
SimpleGraph.Walk.darts_cycleBypass_sublist_darts | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {v : V} [inst : DecidableEq V] (w : G.Walk v v), w.cycleBypass.darts.Sublist w.darts | null | true |
Ordnode.repr._f | Mathlib.Data.Ordmap.Ordnode | {α : Type u_2} → [Repr α] → ℕ → (o : Ordnode α) → Ordnode.below o → Std.Format | null | false |
AddOpposite.instNonUnitalNonAssocSemiring._proof_2 | Mathlib.Algebra.Ring.Opposite | ∀ {R : Type u_1} [inst : NonUnitalNonAssocSemiring R] (a b c : Rᵃᵒᵖ), (a + b) * c = a * c + b * c | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.