name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Init.Data.Array.Lemmas.0.Array.back?_eq_none_iff._proof_1_3 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α}, ¬(¬xs.size - 1 < xs.size ↔ xs.size = 0) → False | null | false |
MeasureTheory.DominatedFinMeasAdditive.of_le | Mathlib.MeasureTheory.Integral.FinMeasAdditive | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {β : Type u_7} [inst : SeminormedAddCommGroup β]
{T : Set α → β} {C C' : ℝ},
MeasureTheory.DominatedFinMeasAdditive μ T C → C ≤ C' → MeasureTheory.DominatedFinMeasAdditive μ T C' | null | true |
prod_properSpace | Mathlib.Topology.MetricSpace.ProperSpace | ∀ {α : Type u_2} {β : Type u_3} [inst : PseudoMetricSpace α] [inst_1 : PseudoMetricSpace β] [ProperSpace α]
[ProperSpace β], ProperSpace (α × β) | A binary product of proper spaces is proper. | true |
Preord.ofHom_id | Mathlib.Order.Category.Preord | ∀ {X : Type u} [inst : Preorder X], Preord.ofHom OrderHom.id = CategoryTheory.CategoryStruct.id ↧X | null | true |
HasFDerivWithinAt.fun_sub | 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 g : E → F}
{f' g' : E →L[𝕜] F} {x : E} {s : Set E},
HasFDerivWithinAt f f' s x → HasFDerivWithinAt g g' s ... | Eta-expanded form of `HasFDerivWithinAt.sub` | true |
Std.Http.Headers.get! | Std.Http.Data.Headers | Std.Http.Headers → Std.Http.Header.Name → Std.Http.Header.Value | Like `get?`, but panics if absent.
| true |
Filter.le_limsup_iff' | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β}
[DenselyOrdered β] {x : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._auto_1 →
autoParam (Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.le_limsup_iff'._au... | A version of `le_limsup_iff` with large inequalities in densely ordered spaces. | true |
Lean.Meta.Sym.AlphaShareCommon.State.set._default | Lean.Meta.Sym.AlphaShareCommon | Lean.PHashSet Lean.Meta.Sym.AlphaKey | null | false |
MonadControl.noConfusionType | Init.Control.Basic | Sort u_1 →
{m : Type u → Type v} →
{n : Type u → Type w} →
MonadControl m n → {m' : Type u → Type v} → {n' : Type u → Type w} → MonadControl m' n' → Sort u_1 | null | false |
AlgebraicGeometry.«term_⤏_» | Mathlib.AlgebraicGeometry.Birational.RationalMap | Lean.TrailingParserDescr | The notation for rational maps. | true |
_private.Mathlib.Tactic.GRewrite.Elab.0.Mathlib.Tactic.GRewrite.updateInfoTree.match_4 | Mathlib.Tactic.GRewrite.Elab | (motive : Lean.Elab.InfoTree → Sort u_1) →
(tree : Lean.Elab.InfoTree) →
((i : Lean.Elab.PartialContextInfo) → (tree : Lean.Elab.InfoTree) → motive (Lean.Elab.InfoTree.context i tree)) →
((i : Lean.Elab.Info) →
(children : Lean.PersistentArray Lean.Elab.InfoTree) → motive (Lean.Elab.InfoTree.node ... | null | false |
_private.Mathlib.Data.PNat.Basic.0.PNat.dvd_iff._simp_1_1 | Mathlib.Data.PNat.Basic | ∀ (n : ℕ+), (↑n = 0) = False | null | false |
CategoryTheory.InducedCategory.Hom.mk | Mathlib.CategoryTheory.InducedCategory | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v, u₂} D] →
{F : C → D} → {X Y : CategoryTheory.InducedCategory D F} → (F X ⟶ F Y) → X.Hom Y | null | true |
_private.Std.Data.DTreeMap.Internal.Model.0.Std.DTreeMap.Internal.Impl.minEntry?ₘ'.match_1.splitter | Std.Data.DTreeMap.Internal.Model | {α : Type u_1} →
{β : α → Type u_2} →
[inst : Ord α] →
(motive : (Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) → Sort u_3) →
(step : Std.DTreeMap.Internal.Impl.ExplorationStep α β fun x => Ordering.lt) →
((ky : α) →
(a : Ordering.lt = Ordering.lt) →
... | null | true |
AlgebraicGeometry.Scheme.PartialMap.comp_assoc | Mathlib.AlgebraicGeometry.Birational.Composition | ∀ {X₁ X₂ X₃ Y : AlgebraicGeometry.Scheme} [inst : PreirreducibleSpace ↥X₁] [inst_1 : IrreducibleSpace ↥X₂]
[inst_2 : Nonempty ↥X₃] (f : X₁.PartialMap X₂) [inst_3 : AlgebraicGeometry.IsDominant f.hom] (g : X₂.PartialMap X₃)
[inst_4 : AlgebraicGeometry.IsDominant g.hom] (h : X₃.PartialMap Y), (f.comp g).comp h = f.co... | null | true |
_private.Lean.Meta.Tactic.Simp.Arith.Nat.Simp.0.Lean.Meta.Simp.Arith.Nat.simpCnstr?.match_1 | Lean.Meta.Tactic.Simp.Arith.Nat.Simp | (motive : Option (Lean.Expr × Lean.Expr) → Sort u_1) →
(__x : Option (Lean.Expr × Lean.Expr)) →
((eNew' h₂ : Lean.Expr) → motive (some (eNew', h₂))) →
((x : Option (Lean.Expr × Lean.Expr)) → motive x) → motive __x | null | false |
_private.Mathlib.Tactic.Positivity.Core.0.Mathlib.Meta.Positivity.nz_of_isRat.match_1_1 | Mathlib.Tactic.Positivity.Core | ∀ {A : Type u_1} {e : A} {n : ℤ} {d : ℕ} [inst : Ring A]
(motive : Mathlib.Meta.NormNum.IsRat e n d → decide (n < 0) = true → Prop) (x : Mathlib.Meta.NormNum.IsRat e n d)
(x_1 : decide (n < 0) = true),
(∀ (inv : Invertible ↑d) (eq : e = ↑n * ⅟↑d) (h : decide (n < 0) = true), motive ⋯ h) → motive x x_1 | null | false |
FiniteField.frobenius_pow | Mathlib.FieldTheory.Finite.Basic | ∀ {K : Type u_1} [inst : Field K] [inst_1 : Fintype K] {p : ℕ} [inst_2 : Fact (Nat.Prime p)] [inst_3 : CharP K p]
{n : ℕ}, Fintype.card K = p ^ n → frobenius K p ^ n = 1 | null | true |
IsDiscreteValuationRing.unit_mul_pow_congr_unit | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] [IsDiscreteValuationRing R] {ϖ : R},
Irreducible ϖ → ∀ (u v : Rˣ) (m n : ℕ), ↑u * ϖ ^ m = ↑v * ϖ ^ n → u = v | null | true |
ContinuousLinearEquiv.toDiffeomorph._proof_2 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {E' : Type u_3} [inst_3 : NormedAddCommGroup E'] [inst_4 : NormedSpace 𝕜 E']
(e : E ≃L[𝕜] E'), ContMDiff (modelWithCornersSelf 𝕜 E) (modelWithCornersSelf 𝕜 E') ↑⊤ ⇑e | null | false |
Fin.foldrM_succ | Init.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {n : ℕ} {α : Type u_1} [inst : Monad m] [LawfulMonad m] (f : Fin (n + 1) → α → m α),
Fin.foldrM (n + 1) f = fun x => Fin.foldrM n (fun i => f i.succ) x >>= f 0 | null | true |
_private.Mathlib.Data.Finset.Lattice.Fold.0.Finset.inf_dite_neg_le._proof_1_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] [inst_1 : OrderTop α] {s : Finset β} (p : β → Prop)
[inst_2 : DecidablePred p] {f : (b : β) → p b → α} {g : (b : β) → ¬p b → α} {b : β},
b ∈ s → ∀ (h₁ : ¬p b), (s.inf fun i => if h : p i then f i h else g i h) ≤ g b h₁ | null | false |
PiTensorProduct.mapLMonoidHom._proof_2 | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} {E : ι → Type u_3} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)],
ContinuousAdd (PiTensorProduct 𝕜 fun i => E i) | null | false |
Filter.CountableGenerateSets.below.basic | Mathlib.Order.Filter.CountableInter | ∀ {α : Type u_2} {g : Set (Set α)} {motive : (a : Set α) → Filter.CountableGenerateSets g a → Prop} {s : Set α}
(a : s ∈ g), Filter.CountableGenerateSets.below ⋯ | null | true |
List.sum_set | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {M : Type u_4} [inst : AddMonoid M] (L : List M) (n : ℕ) (a : M),
(L.set n a).sum = ((List.take n L).sum + if n < L.length then a else 0) + (List.drop (n + 1) L).sum | null | true |
CategoryTheory.Functor.PushoutObjObj.ofNatIso | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{X₁... | Transport a `Functor.PushoutObjObj` structure via a natural isomorphism of functors. | true |
LinearMap.convOne_apply | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {A : Type u_3} {C : Type u_5} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : AddCommMonoid C] [inst_4 : Module R C] [inst_5 : CoalgebraStruct R C] (c : C),
(WithConv.ofConv 1) c = (algebraMap R A) (CoalgebraStruct.counit c) | null | true |
Lean.IR.IRType.below | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.IRType → Sort u} →
{motive_2 : Array Lean.IR.IRType → Sort u} →
{motive_3 : List Lean.IR.IRType → Sort u} → Lean.IR.IRType → Sort (max 1 u) | null | false |
_private.Mathlib.NumberTheory.ModularForms.Discriminant.0.ModularForm.discriminant_eq_q_prod._simp_1_3 | Mathlib.NumberTheory.ModularForms.Discriminant | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (n • x) | null | false |
_private.Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno.0.OrderedFinpartition.eraseMiddle._simp_5 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (a b : Fin n), (a = b) = (↑a = ↑b) | null | false |
instRingWithIdealFilter._proof_7 | Mathlib.RingTheory.IdealFilter.Topology | ∀ {A : Type u_1} [inst : Ring A] (x : IdealFilter A) (a : WithIdealFilter x), a + 0 = a | null | false |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.pushPending | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Unit | null | true |
Localization.algEquiv_symm_mk | Mathlib.RingTheory.Localization.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Submonoid R} {S : Type u_2} [inst_1 : CommSemiring S]
[inst_2 : Algebra R S] [inst_3 : IsLocalization M S] (x : R) (y : ↥M),
(Localization.algEquiv M S).symm (IsLocalization.mk' S x y) = Localization.mk x y | null | true |
String.ofList._proof_1 | Init.Prelude | ∀ (data : List Char), data.utf8Encode.IsValidUTF8 | null | false |
_private.Lean.Util.CollectAxioms.0.Lean.CollectAxioms.State.ctorIdx | Lean.Util.CollectAxioms | Lean.CollectAxioms.State✝ → ℕ | null | false |
_private.Mathlib.AlgebraicGeometry.OrderOfVanishing.0.AlgebraicGeometry.Scheme.ord_le_smul._simp_1_6 | Mathlib.AlgebraicGeometry.OrderOfVanishing | ∀ (X : AlgebraicGeometry.Scheme) [AlgebraicGeometry.IsIntegral X] {U : X.Opens} (x : ↥X) (hx : x ∈ U),
Function.Injective ⇑(CategoryTheory.ConcreteCategory.hom (X.presheaf.germ U x hx)) = True | null | false |
Subfield.instMulActionSubtypeMem._proof_2 | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u_2} [inst : DivisionRing K] {X : Type u_1} [inst_1 : MulAction K X] (b : X), 1 • b = b | null | false |
CategoryTheory.Limits.biprod.congr_simp | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(X X_1 : C) (e_X : X = X_1) (Y Y_1 : C) (e_Y : Y = Y_1) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y],
(X ⊞ Y) = (X_1 ⊞ Y_1) | null | true |
Std.Time.FormatType | Std.Time.Format.Basic | Type → Std.Time.FormatString → Type | null | true |
instIsLeftCancelSMulOfIsLeftCancelMul | Mathlib.Algebra.Group.Action.Defs | ∀ (G : Type u_9) [inst : Mul G] [IsLeftCancelMul G], IsLeftCancelSMul G G | null | true |
Matrix.addGroup._proof_4 | Mathlib.LinearAlgebra.Matrix.Defs | ∀ {m : Type u_1} {n : Type u_2} {α : Type u_3} [inst : AddGroup α],
autoParam (∀ (n_1 : ℕ) (a : Matrix m n α), Int.negSucc n_1 • a = -(↑n_1.succ • a)) SubNegMonoid.zsmul_neg'._autoParam | null | false |
IsIntegrallyClosed.of_iInf_eq_bot | Mathlib.RingTheory.LocalProperties.IntegrallyClosed | ∀ {R : Type u_1} {K : Type u_2} [inst : CommRing R] [inst_1 : Field K] [inst_2 : Algebra R K] [IsFractionRing R K]
{ι : Type u_3} (S : ι → Subalgebra R K), (∀ (i : ι), IsIntegrallyClosed ↥(S i)) → ⨅ i, S i = ⊥ → IsIntegrallyClosed R | null | true |
_private.Lean.Message.0.Lean.MessageData.hasSyntheticSorry.visit._sparseCasesOn_1 | Lean.Message | {motive_1 : Lean.MessageData → Sort u} →
(t : Lean.MessageData) →
((f : Option Lean.PPContext → BaseIO Dynamic) →
(hasSyntheticSorry : Lean.MetavarContext → Bool) → motive_1 (Lean.MessageData.ofLazy f hasSyntheticSorry)) →
((a : Lean.MessageDataContext) → (a_1 : Lean.MessageData) → motive_1 (Lean.Me... | null | false |
conjneg_ne_zero | Mathlib.Algebra.Star.Conjneg | ∀ {G : Type u_2} {R : Type u_3} [inst : AddGroup G] [inst_1 : CommSemiring R] [inst_2 : StarRing R] {f : G → R},
conjneg f ≠ 0 ↔ f ≠ 0 | null | true |
Lean.Elab.FieldRedeclInfo.recOn | Lean.Elab.InfoTree.Types | {motive : Lean.Elab.FieldRedeclInfo → Sort u} →
(t : Lean.Elab.FieldRedeclInfo) → ((stx : Lean.Syntax) → motive { stx := stx }) → motive t | null | false |
Multiset.disjoint_finset_sum_left | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} {i : Finset ι} {f : ι → Multiset α} {a : Multiset α},
Disjoint (i.sum f) a ↔ ∀ b ∈ i, Disjoint (f b) a | **Alias** of `Multiset.disjoint_finsetSum_left`. | true |
Finsupp.mem_range_mapDomain_iff | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : AddCommMonoid M] (f : α → β),
Function.Injective f → ∀ (x : β →₀ M), x ∈ Set.range (Finsupp.mapDomain f) ↔ ∀ b ∉ Set.range f, x b = 0 | null | true |
_private.Lean.Elab.PreDefinition.Main.0.Lean.Elab.isNonRecursive | Lean.Elab.PreDefinition.Main | Lean.Elab.PreDefinition → Bool | null | true |
Turing.ToPartrec.instDecidableEqCode | Mathlib.Computability.TuringMachine.Config | DecidableEq Turing.ToPartrec.Code | null | true |
Std.Async.TCP.Socket.Client.noConfusion | Std.Async.TCP | {P : Sort u} → {t t' : Std.Async.TCP.Socket.Client} → t = t' → Std.Async.TCP.Socket.Client.noConfusionType P t t' | null | false |
CompactlyCoherentSpace.casesOn | Mathlib.Topology.Compactness.CompactlyCoherentSpace | {X : Type u_1} →
[inst : TopologicalSpace X] →
{motive : CompactlyCoherentSpace X → Sort u} →
(t : CompactlyCoherentSpace X) →
((isCoherentWith : Topology.IsCoherentWith {K | IsCompact K}) → motive ⋯) → motive t | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.IsCycle.snd_ne_penultimate._proof_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} {p : G.Walk u u}, 3 ≤ p.length → 1 ≤ p.length | null | false |
Real.sigmoid_pos | Mathlib.Analysis.SpecialFunctions.Sigmoid | ∀ (x : ℝ), 0 < x.sigmoid | null | true |
_private.Init.Data.List.Nat.Sublist.0.List.append_sublist_of_sublist_right._proof_1_1 | Init.Data.List.Nat.Sublist | ∀ {α : Type u_1} {xs ys zs : List α}, zs.length ≤ ys.length → xs.length + ys.length ≤ zs.length → ¬xs.length = 0 → False | null | false |
le_max_iff._simp_1 | Mathlib.Order.Defs.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α}, (c ≤ max a b) = (c ≤ a ∨ c ≤ b) | null | false |
CategoryTheory.Arrow.LeftHomotopy.comp_hom | Mathlib.CategoryTheory.Preadditive.FreydCategory.Homotopy | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] [inst_1 : CategoryTheory.Preadditive V]
{u v w : CategoryTheory.Arrow V} {f₁ g₁ : u ⟶ v} {f₂ g₂ : v ⟶ w} (h₁ : CategoryTheory.Arrow.LeftHomotopy f₁ g₁)
(h₂ : CategoryTheory.Arrow.LeftHomotopy f₂ g₂),
(h₁.comp h₂).hom =
CategoryTheory.CategoryStruc... | null | true |
Module.AEval.restrict_equiv_mapSubmodule._proof_3 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(p : Submodule R M), IsScalarTower R R ↥p | null | false |
Mathlib.Meta.NormNum.IsNNRat.to_eq | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : DivisionSemiring α] {n d : ℕ} {a n' d' : α},
Mathlib.Meta.NormNum.IsNNRat a n d → ↑n = n' → ↑d = d' → a = n' / d' | null | true |
Lean.Meta.Grind.instInhabitedEMatchTheoremConstraint | Lean.Meta.Tactic.Grind.Extension | Inhabited Lean.Meta.Grind.EMatchTheoremConstraint | null | true |
Localization.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : CommMonoid M] (S : Submonoid M), Localization S = OreLocalization S M | null | true |
Inclusion.instMonadBacktrackProdSavedStateStateInclusionM | Mathlib.Tactic.Inclusion.Core.Types | Lean.MonadBacktrack (Lean.Meta.SavedState × Inclusion.InclusionM.State) Inclusion.InclusionM | null | true |
_private.Batteries.Data.BinaryHeap.WF.0.Batteries.BinaryHeap.WF.ParentGeChildren.set_of_ge._proof_1_6 | Batteries.Data.BinaryHeap.WF | ∀ {α : Type u_1} {sz : ℕ} {x : α} [inst : Ord α] [Std.TransOrd α] {v : Vector α sz} {i : Fin sz},
(compare x v[i]).isGE = true →
(∀ (x : 2 * ↑i + 1 < sz), (compare v[i] v[2 * ↑i + 1]).isGE = true) →
∀ (x_1 : 2 * ↑i + 1 < sz),
↑i = 0 → (compare (v.set (↑i) x ⋯)[(↑i - 1) / 2] (v.set (↑i) x ⋯)[2 * ↑i +... | null | false |
Std.TreeMap.Raw.instCoeWFWFInner | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → {t : Std.TreeMap.Raw α β cmp} → Coe t.WF t.inner.WF | null | true |
MonomialOrder.leadingTerm_add_of_lt | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommSemiring R] {f g : MvPolynomial σ R},
m.toSyn (m.degree g) < m.toSyn (m.degree f) → m.leadingTerm (f + g) = m.leadingTerm f | null | true |
NNReal.iSup_div | Mathlib.Basic.NNReal.Basic | ∀ {ι : Sort u_3} (f : ι → NNReal) (a : NNReal), (⨆ i, f i) / a = ⨆ i, f i / a | null | true |
List.dropWhile_eq_self_iff | Mathlib.Data.List.TakeWhile | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, List.dropWhile p l = l ↔ ∀ (hl : 0 < l.length), ¬p l[0] = true | null | true |
map_mem_separableClosure_iff | Mathlib.FieldTheory.SeparableClosure | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {K : Type w} [inst_3 : Field K]
[inst_4 : Algebra F K] (i : E →ₐ[F] K) {x : E}, i x ∈ separableClosure F K ↔ x ∈ separableClosure F E | If `i` is an `F`-algebra homomorphism from `E` to `K`, then `i x` is contained in
`separableClosure F K` if and only if `x` is contained in `separableClosure F E`. | true |
UInt32.toBitVec_toUInt8 | Init.Data.UInt.Lemmas | ∀ (n : UInt32), n.toUInt8.toBitVec = BitVec.setWidth 8 n.toBitVec | null | true |
Aesop.PostponedSafeRule.mk._flat_ctor | Aesop.Tree.UnsafeQueue | Aesop.SafeRule → Aesop.RuleTacOutput → Aesop.PostponedSafeRule | null | false |
AddGroupSeminorm.toSeminormedAddGroup._proof_1 | Mathlib.Analysis.Normed.Group.Defs | ∀ {E : Type u_1} [inst : AddGroup E] (f : AddGroupSeminorm E) (x : E), f (-x + x) = 0 | null | false |
CategoryTheory.instHasLimitsInd | Mathlib.CategoryTheory.Limits.Indization.Category | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.Limits.HasLimits C],
CategoryTheory.Limits.HasLimits (CategoryTheory.Ind C) | null | true |
Nat.choose_lt_pow | Mathlib.Data.Nat.Choose.Bounds | ∀ {n k : ℕ}, n ≠ 0 → 2 ≤ k → n.choose k < n ^ k | null | true |
String.Slice.SplitIterator.instIteratorIdSubslice.eq_1 | Init.Data.String.Slice | ∀ {ρ : Type} {σ : String.Slice → Type}
[inst : (s : String.Slice) → Std.Iterator (σ s) Id (String.Slice.Pattern.SearchStep s)] {pat : ρ}
[inst_1 : String.Slice.Pattern.ToForwardSearcher pat σ] {s : String.Slice},
String.Slice.SplitIterator.instIteratorIdSubslice =
{
IsPlausibleStep := fun x x_1 =>
... | null | true |
BitVec.forall_zero_iff | Init.Data.BitVec.Decidable | ∀ {P : BitVec 0 → Prop}, (∀ (v : BitVec 0), P v) ↔ P 0#0 | null | true |
_private.Mathlib.Topology.DiscreteSubset.0.isClosed_and_discrete_iff._simp_1_1 | Mathlib.Topology.DiscreteSubset | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | null | false |
Subspace.orderIsoFiniteCodimDim._proof_2 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_1} {V : Type u_2} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : { W // FiniteDimensional K ↥W }ᵒᵈ), FiniteDimensional K (V ⧸ Submodule.dualCoannihilator ↑(OrderDual.ofDual W)) | null | false |
Lean.Compiler.LCNF.instBEqParam.beq | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.Param pu → Lean.Compiler.LCNF.Param pu → Bool | null | true |
_private.Mathlib.Data.Seq.Parallel.0.Computation.parallel.aux1.eq_1 | Mathlib.Data.Seq.Parallel | ∀ {α : Type u} (l : List (Computation α)) (S : Stream'.WSeq (Computation α)),
Computation.parallel.aux1✝ (l, S) =
Computation.rmap
(fun l' =>
match Stream'.Seq.destruct S with
| none => (l', Stream'.Seq.nil)
| some (none, S') => (l', S')
| some (some c, S') => (c :: l', S'))
... | null | true |
ULift.seminormedRing | Mathlib.Analysis.Normed.Ring.Basic | {α : Type u_2} → [SeminormedRing α] → SeminormedRing (ULift.{u_5, u_2} α) | null | true |
TensorProduct.AlgebraTensorModule.congr_symm_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | null | true |
CategoryTheory.Triangulated.SpectralObject.recOn | Mathlib.CategoryTheory.Triangulated.SpectralObject | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Limits.HasZeroObject C] →
[inst_3 : CategoryTheory.HasShift C ℤ] →
[inst_4 : CategoryTheory.Preadditive C] →
... | null | false |
List.min?_eq_none_iff._simp_1 | Init.Data.List.MinMax | ∀ {α : Type u_1} {xs : List α} [inst : Min α], (xs.min? = none) = (xs = []) | null | false |
_private.Mathlib.Order.Cover.0.WithTop.coe_wcovBy_top._simp_1_2 | Mathlib.Order.Cover | ∀ {α : Type u_1} [inst : Preorder α] {a : α}, Set.Ioo ↑a ⊤ = WithTop.some '' Set.Ioi a | null | false |
Std.DTreeMap.Internal.Impl.balanceLErase._proof_14 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u_1} {β : α → Type u_2} (rs : ℕ) (k : α) (v : β k) (l r : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Internal.Impl.inner rs k v l r).Balanced →
∀ (ls : ℕ) (lk : α) (lv : β lk),
Std.DTreeMap.Internal.delta * rs < ls →
∀ (x : Std.DTreeMap.Internal.Impl α β),
(Std.DTreeMap.Int... | null | false |
_private.Mathlib.LinearAlgebra.Prod.0.Submodule.map_inl._simp_1_7 | Mathlib.LinearAlgebra.Prod | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {M' : Type u_8}
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] {p : Submodule R M} {q : Submodule R M'} {x : M × M'},
(x ∈ p.prod q) = (x.1 ∈ p ∧ x.2 ∈ q) | null | false |
AddMonoidHom.ext_nat | Mathlib.Algebra.Group.Nat.Hom | ∀ {A : Type u_2} [inst : AddZeroClass A] {f g : ℕ →+ A}, f 1 = g 1 → f = g | null | true |
Complex.measurableEquivRealProd | Mathlib.MeasureTheory.Measure.Lebesgue.Complex | ℂ ≃ᵐ ℝ × ℝ | Measurable equivalence between `ℂ` and `ℝ × ℝ`. | true |
_private.Mathlib.Data.ENat.Pow.0.ENat.epow_top._proof_1_3 | Mathlib.Data.ENat.Pow | ¬⊤ < ⊤ | null | false |
Polynomial.divModByMonicAux.congr_simp | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : Ring R] (_p _p_1 : Polynomial R),
_p = _p_1 → ∀ {q q_1 : Polynomial R} (e_q : q = q_1) (a : q.Monic), _p.divModByMonicAux a = _p_1.divModByMonicAux ⋯ | null | true |
List.infix_append' | Init.Data.List.Sublist | ∀ {α : Type u_1} (l₁ l₂ l₃ : List α), l₂ <:+: l₁ ++ (l₂ ++ l₃) | null | true |
SetLike.GradeZero.instRing._aux_6 | Mathlib.Algebra.DirectSum.Internal | {ι : Type u_3} →
{σ : Type u_2} →
{R : Type u_1} →
[inst : Ring R] →
[inst_1 : AddMonoid ι] →
[inst_2 : SetLike σ R] → [AddSubgroupClass σ R] → (A : ι → σ) → [SetLike.GradedMonoid A] → ℤ → ↥(A 0) | null | false |
LinearMap.re_inner_adjoint_mul_self_nonneg | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
[inst_3 : FiniteDimensional 𝕜 E] (T : E →ₗ[𝕜] E) (x : E), 0 ≤ RCLike.re (inner 𝕜 x ((LinearMap.adjoint T * T) x)) | The Gram operator T†T is a positive operator. | true |
Algebra.norm_eq_of_ringEquiv | Mathlib.RingTheory.Norm.Basic | ∀ {A : Type u_8} {B : Type u_9} {C : Type u_10} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Ring C]
[inst_3 : Algebra A C] [inst_4 : Algebra B C] (e : A ≃+* B),
(algebraMap B C).comp ↑e = algebraMap A C → ∀ (x : C), e ((Algebra.norm A) x) = (Algebra.norm B) x | null | true |
_private.Lean.Elab.PatternVar.0.Lean.Elab.Term.CollectPatternVars.collect.processId.match_1 | Lean.Elab.PatternVar | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((val : Lean.ConstructorVal) → motive (some (Lean.ConstantInfo.ctorInfo val))) →
((val : Lean.ConstantInfo) → motive (some val)) → (Unit → motive none) → motive x | null | false |
_private.Mathlib.Tactic.Linter.FindDeprecations.0.Mathlib.Tactic.rewriteOneFile.match_7 | Mathlib.Tactic.Linter.FindDeprecations | (motive : List String.Pos.Raw → Sort u_1) →
(x : List String.Pos.Raw) →
((a b _c : String.Pos.Raw) → motive [a, b, _c]) → ((x : List String.Pos.Raw) → motive x) → motive x | null | false |
_private.Lean.Meta.Transform.0.Lean.Meta.unfoldIfArgIsAppOf._sparseCasesOn_1 | Lean.Meta.Transform | {motive : Lean.ConstantInfo → Sort u} →
(t : Lean.ConstantInfo) →
((val : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo val)) →
(Nat.hasNotBit 4 t.ctorIdx → motive t) → motive t | null | false |
AlgebraicGeometry.one_spec_asOver_spec | Mathlib.AlgebraicGeometry.Group.Affine | ∀ {R A : CommRingCat} [inst : Bialgebra ↑R ↑A],
CategoryTheory.MonObj.one =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.LaxMonoidal.ε (AlgebraicGeometry.algSpec R))
(CategoryTheory.Over.homMk (AlgebraicGeometry.Spec.map (CommRingCat.ofHom ↑(Bialgebra.counitAlgHom ↑R ↑A))) ⋯) | null | true |
CategoryTheory.Limits.HasWideCoequalizer | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | {J : Type w} → {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y : C} → (J → (X ⟶ Y)) → Prop | A family `f` of parallel morphisms has a wide coequalizer if the diagram `parallelFamily f` has
a colimit. | true |
IsCompact.of_subset_of_specializes | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s t : Set X},
IsCompact s → t ⊆ s → (∀ x ∈ s, ∃ y ∈ t, x ⤳ y) → IsCompact t | null | true |
_private.Mathlib.Analysis.SpecificLimits.Normed.0.TFAE_exists_lt_isLittleO_pow.match_1_7 | Mathlib.Analysis.SpecificLimits.Normed | ∀ (f : ℕ → ℝ) (R : ℝ) (motive : (∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x) → Prop)
(x : ∃ a ∈ Set.Ioo 0 R, f =O[Filter.atTop] fun x => a ^ x),
(∀ (a : ℝ) (ha : a ∈ Set.Ioo 0 R) (H : f =O[Filter.atTop] fun x => a ^ x), motive ⋯) → motive x | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.