name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanIleanInfoParams → Sort u} →
(t : Lean.Lsp.LeanIleanInfoParams) →
((version : ℕ) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) → motive { version := version, references := references, decls := decls }) →
motive t | null | false |
Std.HashMap.Raw.getElem_congr | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : EquivBEq α]
[inst_3 : LawfulHashable α] (h : m.WF) {a b : α} (hab : (a == b) = true) {h' : a ∈ m}, m[a] = m[b] | null | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | ∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), m₁.grevlex m₂ = m₁.grevlex_k m₂ | null | false |
Complex.isOpen_im_lt_EReal | Mathlib.Analysis.Complex.HalfPlane | ∀ (x : EReal), IsOpen {z | ↑z.im < x} | An open lower half-plane (with boundary imaginary part given by an `EReal`) is an open set
in the complex plane. | true |
CategoryTheory.Bundled.mk.noConfusion | Mathlib.CategoryTheory.ConcreteCategory.Bundled | {c : Type u → Type v} →
{P : Sort u_1} →
{α : Type u} →
{str : autoParam (c α) CategoryTheory.Bundled.str._autoParam} →
{α' : Type u} →
{str' : autoParam (c α') CategoryTheory.Bundled.str._autoParam} →
{ α := α, str := str } = { α := α', str := str' } → (α = α' → str ≍ str' → P... | null | false |
Std.ExtDTreeMap.size_le_size_erase | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
{k : α}, t.size ≤ (t.erase k).size + 1 | null | true |
_private.Mathlib.Algebra.Homology.ExactSequenceFour.0.CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._proof_8 | Mathlib.Algebra.Homology.ExactSequenceFour | ∀ {n : ℕ} (k : ℕ) (hk : autoParam (k ≤ n) CategoryTheory.ComposableArrows.Exact.opcyclesIsoCycles._auto_1),
⟨k, ⋯⟩ ≤ ⟨k + 1, ⋯⟩ | null | false |
riemannZeta.eq_1 | Mathlib.NumberTheory.LSeries.RiemannZeta | riemannZeta = HurwitzZeta.hurwitzZetaEven 0 | null | true |
CategoryTheory.ProjectivePresentation.noConfusionType | Mathlib.CategoryTheory.Preadditive.Projective.Basic | Sort u_1 →
{C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X : C} →
CategoryTheory.ProjectivePresentation X →
{C' : Type u} →
[inst' : CategoryTheory.Category.{v, u} C'] →
{X' : C'} → CategoryTheory.ProjectivePresentation X' → Sort u_1 | null | false |
RatFunc.irreducible_minpolyX | Mathlib.FieldTheory.RatFunc.IntermediateField | ∀ {K : Type u_1} [inst : Field K] (f : RatFunc K), (¬∃ c, f = RatFunc.C c) → Irreducible (f.minpolyX ↥K⟮f⟯) | null | true |
WeakSpace.instModule' | Mathlib.Topology.Algebra.Module.Spaces.WeakDual | {𝕜 : Type u_2} →
{𝕝 : Type u_3} →
{E : Type u_4} →
[inst : CommSemiring 𝕜] →
[inst_1 : TopologicalSpace 𝕜] →
[inst_2 : ContinuousAdd 𝕜] →
[inst_3 : ContinuousConstSMul 𝕜 𝕜] →
[inst_4 : AddCommMonoid E] →
[inst_5 : Module 𝕜 E] →
... | null | true |
_private.Mathlib.MeasureTheory.Measure.HasOuterApproxClosed.0.MeasureTheory.measure_of_cont_bdd_of_tendsto_filter_indicator._simp_1_1 | Mathlib.MeasureTheory.Measure.HasOuterApproxClosed | ∀ {α : Type u_1} {m : MeasurableSpace α}, MeasurableSet Set.univ = True | null | false |
Filter.comk.congr_simp | Mathlib.Order.Filter.Basic | ∀ {α : Type u_1} (p p_1 : Set α → Prop) (e_p : p = p_1) (he : p ∅) (hmono : ∀ (t : Set α), p t → ∀ s ⊆ t, p s)
(hunion : ∀ (s : Set α), p s → ∀ (t : Set α), p t → p (s ∪ t)), Filter.comk p he hmono hunion = Filter.comk p_1 ⋯ ⋯ ⋯ | null | true |
CategoryTheory.Pretriangulated.Triangle.epi₃ | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
∀ T ∈ CategoryTheory.Pr... | null | true |
CategoryTheory.Subfunctor.range | Mathlib.CategoryTheory.Subfunctor.Image | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{F F' : CategoryTheory.Functor C (Type w)} → (F' ⟶ F) → CategoryTheory.Subfunctor F | The range of a morphism of type-valued functors, as a subfunctor of the target. | true |
QuaternionAlgebra.equivProd | Mathlib.Algebra.Quaternion | {R : Type u_1} → (c₁ c₂ c₃ : R) → QuaternionAlgebra R c₁ c₂ c₃ ≃ R × R × R × R | The equivalence between a quaternion algebra over `R` and `R × R × R × R`. | true |
AddSemigroupIdeal.fg_iff | Mathlib.Algebra.Group.Ideal | ∀ {M : Type u_1} [inst : Add M] {I : AddSemigroupIdeal M}, I.FG ↔ ∃ s, I = AddSemigroupIdeal.closure ↑s | null | true |
_private.Init.Data.String.Lemmas.Pattern.Pred.0.String.Slice.Pattern.Model.CharPred.Decidable.matchesAt_iff_matchesAt_decide._simp_1_2 | Init.Data.String.Lemmas.Pattern.Pred | ∀ {p : Char → Prop} [inst : DecidablePred p] {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestMatchAt p pos pos' =
String.Slice.Pattern.Model.IsLongestMatchAt (fun x => decide (p x)) pos pos' | null | false |
Vector.set_mk._proof_3 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n) {i : ℕ} {x : α} (w : i < n), (xs.set i x ⋯).size = n | null | false |
Std.ExtTreeMap.isEmpty_eq_size_beq_zero | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp}, t.isEmpty = (t.size == 0) | null | true |
NormedAddGroupHom.incl._proof_3 | Mathlib.Analysis.Normed.Group.Hom | ∀ {V : Type u_1} [inst : SeminormedAddCommGroup V] (s : AddSubgroup V), ∃ C, ∀ (v : ↥s), ‖↑v‖ ≤ C * ‖v‖ | null | false |
Part.Mem | Mathlib.Data.Part | {α : Type u_1} → Part α → α → Prop | `a ∈ o` means that `o` is defined and equal to `a` | true |
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.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 |
instWeakEMetricSpaceENNReal._proof_6 | Mathlib.Topology.EMetricSpace.Weak | (uniformSpaceOfEDist edist instWeakEMetricSpaceENNReal._proof_3 instWeakEMetricSpaceENNReal._proof_4
instWeakEMetricSpaceENNReal._proof_5).toTopologicalSpace ≤
ENNReal.instTopologicalSpace | null | false |
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 |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.