name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
CategoryTheory.FreeBicategory.bicategory._proof_16 | Mathlib.CategoryTheory.Bicategory.Free | ∀ {B : Type u_1} [inst : Quiver B] (x x_1 x_2 : CategoryTheory.FreeBicategory B) (f : x ⟶ x_1) (g : x_1 ⟶ x_2),
Quot.mk CategoryTheory.FreeBicategory.Rel
(CategoryTheory.FreeBicategory.Hom₂.whisker_right g (CategoryTheory.FreeBicategory.Hom₂.id f)) =
Quot.mk CategoryTheory.FreeBicategory.Rel
(Category... | null | false |
Module.erange_coe | Mathlib.LinearAlgebra.Dual.Defs | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.IsReflexive R M], (Module.Dual.eval R M).range = ⊤ | null | true |
ONote.toString._sparseCasesOn_1.else_eq | Mathlib.SetTheory.Ordinal.Notation | ∀ {motive : ONote → Sort u} (t : ONote) (zero : motive ONote.zero) («else» : Nat.hasNotBit 1 t.ctorIdx → motive t)
(h : Nat.hasNotBit 1 t.ctorIdx), ONote.toString._sparseCasesOn_1 t zero «else» = «else» h | null | false |
FirstOrder.Language.Term.realize_substFunc | Mathlib.ModelTheory.Semantics | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {β : Type v'}
[inst_1 : L'.Structure M] {c : {n : ℕ} → L.Functions n → L'.Term (Fin n)},
(∀ {n : ℕ} (g : L.Functions n) (y : Fin n → M),
FirstOrder.Language.Term.realize y g.term = FirstOrder.Language.Term.realize y (c ... | null | true |
Finmap | Mathlib.Data.Finmap | {α : Type u} → (α → Type v) → Type (max u v) | `Finmap β` is the type of finite maps over a multiset. It is effectively
a quotient of `AList β` by permutation of the underlying list. | true |
Batteries.HashMap.mk.inj | Batteries.Data.HashMap.Basic | ∀ {α : Type u} {β : Type v} {inst : BEq α} {inst_1 : Hashable α} {inner inner_1 : Std.HashMap α β},
{ inner := inner } = { inner := inner_1 } → inner = inner_1 | null | true |
Born.instLargeCategory._proof_1 | Mathlib.Topology.Category.Born | ∀ {X Y : Born} (f : LocallyBoundedMap X.carrier Y.carrier), f.comp (LocallyBoundedMap.id X.carrier) = f | null | false |
AddSubmonoid.prod_mono | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {N : Type u_2} [inst : AddZeroClass N] {M : Type u_5} [inst_1 : AddZeroClass M] {s₁ s₂ : AddSubmonoid M}
{t₁ t₂ : AddSubmonoid N}, s₁ ≤ s₂ → t₁ ≤ t₂ → s₁.prod t₁ ≤ s₂.prod t₂ | null | true |
AlternatingMap.domDomCongr_apply | Mathlib.LinearAlgebra.Alternating.Basic | ∀ {R : Type u_1} [inst : Semiring R] {M : Type u_2} [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] {ι : Type u_7} {ι' : Type u_8} (σ : ι ≃ ι') (f : M [⋀^ι]→ₗ[R] N)
(v : ι' → M), (AlternatingMap.domDomCongr σ f) v = f (v ∘ ⇑σ) | null | true |
IntermediateField.algebraAdjoinAdjoin.instAlgebraSubtypeMemSubalgebraAdjoinAdjoin | Mathlib.FieldTheory.IntermediateField.Adjoin.Algebra | (F : Type u_1) →
[inst : Field F] →
{E : Type u_2} →
[inst_1 : Field E] →
[inst_2 : Algebra F E] → (S : Set E) → Algebra ↥(Algebra.adjoin F S) ↥(IntermediateField.adjoin F S) | `IntermediateField.adjoin` as an algebra over `Algebra.adjoin`. | true |
_private.Mathlib.Geometry.Manifold.Instances.Real.0.boundary_Icc._simp_1_1 | Mathlib.Geometry.Manifold.Instances.Real | ∀ {α : Type u} (s : Set α) (x : α), (x ∉ s) = (x ∈ sᶜ) | null | false |
Primrec.nat_omega_rec' | Mathlib.Computability.Primrec.List | ∀ {β : Type u_2} {σ : Type u_3} [inst : Primcodable β] [inst_1 : Primcodable σ] (f : β → σ) {m : β → ℕ} {l : β → List β}
{g : β → List σ → Option σ},
Primrec m →
Primrec l →
Primrec₂ g → (∀ (b b' : β), b' ∈ l b → m b' < m b) → (∀ (b : β), g b (List.map f (l b)) = some (f b)) → Primrec f | null | true |
Algebra.Generators.algebraMap_eq | Mathlib.RingTheory.Extension.Generators | ∀ {R : Type u} {S : Type v} {ι : Type w} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
(self : Algebra.Generators R S ι), algebraMap (MvPolynomial ι R) S = ↑(MvPolynomial.aeval self.val) | null | true |
DiscrTreeExt.State.tree._default | Mathlib.Tactic.Inclusion.Core.DiscrTreeExt | {α : Type} → Lean.Meta.DiscrTree α | null | false |
HomologicalComplex.stupidTruncMap.eq_1 | Mathlib.Algebra.Homology.Embedding.StupidTrunc | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} {C : Type u_3}
[inst : CategoryTheory.Category.{v_1, u_3} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {K L : HomologicalComplex C c'} (φ : K ⟶ L) (e : c.Embedding c')
[inst_3 : ... | null | true |
_private.Std.Time.Time.Unit.Basic.0.Std.Time.Millisecond.Offset.toHours._proof_1 | Std.Time.Time.Unit.Basic | 1 / 1000 * ↑3600000 = 3600 | null | false |
_private.Mathlib.CategoryTheory.Sites.Precoverage.0.CategoryTheory.Precoverage.mem_coverings_of_isPullback.match_1_1 | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
(f : (i : ι) → X i ⟶ S) {Y : C} {P : ι → C} (p₁ : (i : ι) → P i ⟶ Y)
(a : ↑(CategoryTheory.Presieve.ofArrows X f).uncurry ⊕ ↑(CategoryTheory.Presieve.ofArrows P p₁).uncurry → ι)
(motive : (Z : C) → (g : Z ⟶ Y) → Cate... | null | false |
Std.TreeMap.getElem!_union_of_not_mem_left | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp] {k : α}
[inst : Inhabited β], k ∉ t₁ → (t₁ ∪ t₂)[k]! = t₂[k]! | null | true |
OrderMonoidHom.one_comp | Mathlib.Algebra.Order.Hom.Monoid | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : MulOneClass α] [inst_4 : MulOneClass β] [inst_5 : MulOneClass γ] (f : α →*o β), OrderMonoidHom.comp 1 f = 1 | null | true |
instBooleanRingCarrierToBddLatToBddDistLatOfAsBoolAlg._proof_19 | Mathlib.Algebra.Category.BoolRing | ∀ {R : Type u_1} [inst : BooleanRing R] (a : ↑(↧(AsBoolAlg R)).toBddDistLat.toBddLat.toLat), a * 1 = a | null | false |
Aesop.NodeState._sizeOf_inst | Aesop.Tree.Data | SizeOf Aesop.NodeState | null | false |
Dyadic.ctorIdx | Init.Data.Dyadic.Basic | Dyadic → ℕ | null | false |
_private.Lean.Compiler.NameMangling.0.String.pushHex.match_1.congr_eq_1 | Lean.Compiler.NameMangling | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (k : ℕ) → motive k.succ),
n = 0 →
(match n with
| 0 => h_1 ()
| k.succ => h_2 k) ≍
h_1 () | null | true |
Ordnode.Bounded.eq_3 | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] (x : WithBot α) (x_1 : WithTop α) (size : ℕ) (l : Ordnode α) (x_3 : α)
(r : Ordnode α), (Ordnode.node size l x_3 r).Bounded x x_1 = (l.Bounded x ↑x_3 ∧ r.Bounded (↑x_3) x_1) | null | true |
QuotientGroup.liftEquiv | Mathlib.GroupTheory.QuotientGroup.Defs | {G : Type u_1} →
{H : Type u_2} →
[inst : Group G] →
[inst_1 : Group H] →
(N : Subgroup G) → [nN : N.Normal] → {φ : G →* H} → Function.Surjective ⇑φ → N = φ.ker → G ⧸ N ≃* H | A surjective group homomorphism `φ : G →* H` with `N = ker(φ)` descends (i.e. `lift`s) to a
group isomorphism `G/N ≃* H`. | true |
Submonoid.map_iInf | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_4} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] {ι : Sort u_5} [Nonempty ι] (f : F),
Function.Injective ⇑f → ∀ (s : ι → Submonoid M), Submonoid.map f (iInf s) = ⨅ i, Submonoid.map f (s i) | null | true |
NumberField.RingOfIntegers.instIsIntegralInt | Mathlib.NumberTheory.NumberField.Basic | ∀ {K : Type u_1} [inst : Field K], Algebra.IsIntegral ℤ (NumberField.RingOfIntegers K) | null | true |
AntitoneOn.tsum_add_one_le_integral | Mathlib.Analysis.SumIntegralComparisons | ∀ {f : ℝ → ℝ},
AntitoneOn f (Set.Ici 0) →
MeasureTheory.IntegrableOn f (Set.Ioi 0) MeasureTheory.volume →
(∀ t ∈ Set.Ioi 0, 0 ≤ f t) → ∑' (n : ℕ), f ↑(n + 1) ≤ ∫ (x : ℝ) in Set.Ioi 0, f x | **Integral test**: bounds the sum from 1 by an integral. | true |
Module.Basis.instFunLike._proof_2 | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(f g : Module.Basis ι R M), ((fun i => f.repr.symm fun₀ | i => 1) = fun i => g.repr.symm fun₀ | i => 1) → f = g | null | false |
Lean.Meta.Grind.EMatchTheoremKind.recOn | Lean.Meta.Tactic.Grind.Extension | {motive : Lean.Meta.Grind.EMatchTheoremKind → Sort u} →
(t : Lean.Meta.Grind.EMatchTheoremKind) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqLhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.eqRhs gen)) →
((gen : Bool) → motive (Lean.Meta.Grind.EMatchTheoremKind.... | null | false |
instReprListOfReprAtom | Init.Data.Repr | {α : Type u_1} → [Repr α] → [ReprAtom α] → Repr (List α) | null | true |
BitVec.ofNatLT_zero | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {h : 0 < 2 ^ w}, 0#'h = 0#w | null | true |
_private.Mathlib.Tactic.Matrix.ListMatrix.0.Mathlib.Tactic.Matrix.ListMatrix.getD_transpose._proof_1_11 | Mathlib.Tactic.Matrix.ListMatrix | ∀ {α : Type u_1} [inst : Zero α] {n j : ℕ} (row : List α) (tl : List (List α)),
¬j + 1 ≤ row.length →
(∀ (i : ℕ), j < (Mathlib.Tactic.Matrix.ListMatrix.transpose n (row :: tl)).length) →
j - row.length < (List.replicate (n - row.length) 0).length | null | false |
NonUnitalSeminormedCommRing.induced._proof_1 | Mathlib.Analysis.Normed.Ring.Basic | ∀ {F : Type u_3} (R : Type u_1) (S : Type u_2) [inst : FunLike F R S] [inst_1 : NonUnitalSeminormedCommRing S] (f : F)
(x : R), dist x x = 0 | null | false |
BoundingSieve.multSum_eq_main_err | Mathlib.NumberTheory.SelbergSieve | ∀ {s : BoundingSieve} (d : ℕ), BoundingSieve.multSum d = s.nu d * s.totalMass + BoundingSieve.rem d | null | true |
Set.IsSelfInv.iInter | Mathlib.Algebra.Group.Pointwise.Set.SelfInv | ∀ {α : Type u_1} [inst : Inv α] {ι : Sort u_3} {s : ι → Set α}, (∀ (i : ι), IsSelfInv (s i)) → IsSelfInv (⋂ i, s i) | null | true |
ContinuousLinearMap.compLpₗ₂._proof_6 | Mathlib.MeasureTheory.Function.LpSpace.Basic | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F], IsBoundedSMul 𝕜 F | null | false |
ValueDistribution.proximity_inv | Mathlib.Analysis.Complex.ValueDistribution.Proximity.Basic | ∀ {f : ℂ → ℂ}, ValueDistribution.proximity f⁻¹ ⊤ = ValueDistribution.proximity f 0 | For complex-valued `f`, establish a simple relation between the proximity functions of `f` and of
`f⁻¹`.
| true |
CategoryTheory.Functor.RightExtension.instSubsingletonIsPointwiseRightKanExtensionAt | Mathlib.CategoryTheory.Functor.KanExtension.Pointwise | ∀ {C : Type u_1} {D : Type u_2} {H : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_4, u_4} H]
{L : CategoryTheory.Functor C D} {F : CategoryTheory.Functor C H} (E : L.RightExtension F) (Y : D),
Subsingleton (E.IsPointwi... | null | true |
UInt64.instIsAlwaysFinite_1 | Init.Data.Range.Polymorphic.UInt | Std.Rxo.IsAlwaysFinite UInt64 | null | true |
DerivedWanted.ofVal.injEq | Batteries.Util.ProofWanted | ∀ {α : Sort u} (val val_1 : α), ({ val := val } = { val := val_1 }) = (val = val_1) | null | true |
MeasurableSpace.SeparatesPoints.casesOn | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | {α : Type u_3} →
[m : MeasurableSpace α] →
{motive : MeasurableSpace.SeparatesPoints α → Sort u} →
(t : MeasurableSpace.SeparatesPoints α) →
((separates : ∀ (x y : α), (∀ (s : Set α), MeasurableSet s → x ∈ s → y ∈ s) → x = y) → motive ⋯) → motive t | null | false |
MulArchimedeanClass.mk_one | Mathlib.Algebra.Order.Archimedean.Class | ∀ {M : Type u_1} [inst : CommGroup M] [inst_1 : LinearOrder M] [inst_2 : IsOrderedMonoid M],
MulArchimedeanClass.mk 1 = ⊤ | null | true |
Module.End.IsSemisimple.iSup_maxGenEigenspace_eq_top_iff | Mathlib.LinearAlgebra.Eigenspace.Semisimple | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{f : Module.End R M}, f.IsSemisimple → (⨆ μ, f.maxGenEigenspace μ = ⊤ ↔ ⨆ μ, f.eigenspace μ = ⊤) | A semisimple endomorphism is triangularizable if and only if it is diagonalizable. | true |
CategoryTheory.MonoidalCategory.MonoidalLeftAction.leftActionOfMonoidalOppositeRightAction | Mathlib.CategoryTheory.Monoidal.Action.Opposites | (C : Type u_1) →
(D : Type u_2) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[inst_2 : CategoryTheory.Category.{v_2, u_2} D] →
[CategoryTheory.MonoidalCategory.MonoidalRightAction Cᴹᵒᵖ D] →
CategoryTheory.MonoidalCategory.Mono... | Define a left action of `C` on `D` from a right action of `Cᴹᵒᵖ` on `D` via
the formula `c ⊙ₗ d := d ⊙ᵣ (mop c)`. | true |
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore._auto_16 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | Lean.Syntax | null | false |
Cardinal.card_iUnion_lt_iff_forall_of_isRegular | Mathlib.SetTheory.Cardinal.Regular | ∀ {c : Cardinal.{u}} {ι α : Type u} {t : ι → Set α},
c.IsRegular → Cardinal.mk ι < c → (Cardinal.mk ↑(⋃ i, t i) < c ↔ ∀ (i : ι), Cardinal.mk ↑(t i) < c) | null | true |
IsDedekindDomain.HeightOneSpectrum.adicCompletion.instField._proof_22 | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] (K : Type u_2) [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R)
(a : IsDedekindDomain.HeightOneSpectrum.adicCompletion K v), -a + a = 0 | null | false |
Std.WP.Spec.throw_ExceptT_lift | Std.WP.Triple.SpecLemmas | ∀ {m : Type u → Type v} {Pred EPred : Type u} [inst : Monad m] [inst_1 : Std.WP.Assertion Pred]
[inst_2 : Std.WP.Assertion EPred] [inst_3 : Std.WP.WPMonad m Pred EPred] {ε α ε' : Type u}
[inst_4 : MonadExceptOf ε m] (err : ε) (post : α → Pred) (epost : (ε' → Pred) × EPred),
⦃
Std.WP.wp (MonadExceptOf.throw er... | null | true |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.elabInsertCastAux.unfoldLHS?._sparseCasesOn_1 | Mathlib.Tactic.Translate.TagUnfoldBoundary | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) → ((fn arg : Lean.Expr) → motive (fn.app arg)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
_private.Batteries.Util.ProofWanted.0.WantedRefKind.defWanted.sizeOf_spec | Batteries.Util.ProofWanted | sizeOf WantedRefKind.defWanted✝ = 1 | null | true |
DiscreteConvolution.convolution_single | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | ∀ {M : Type u_1} {S : Type u_2} {E : Type u_3} {F : Type u_5} [inst : Monoid M] [inst_1 : CommSemiring S]
[inst_2 : AddCommMonoid E] [inst_3 : AddCommMonoid F] [inst_4 : Module S E] [inst_5 : Module S F]
[inst_6 : TopologicalSpace F] [inst_7 : DecidableEq M] (L : F →ₗ[S] E →ₗ[S] F) (e : E) (f : M → F),
(∀ (y : F)... | null | true |
Nat.Abundant.pos | Mathlib.NumberTheory.FactorisationProperties | ∀ {n : ℕ}, n.Abundant → 0 < n | null | true |
MulEquiv.instEquivLike.eq_1 | Mathlib.Algebra.Group.Equiv.Defs | ∀ {M : Type u_4} {N : Type u_5} [inst : Mul M] [inst_1 : Mul N],
MulEquiv.instEquivLike =
{ coe := fun f => f.toFun, inv := fun f => f.invFun, left_inv := ⋯, right_inv := ⋯, coe_injective' := ⋯ } | null | true |
Nat.squarefree_two | Mathlib.Data.Nat.Squarefree | Squarefree 2 | null | true |
Std.TreeMap.Raw.getElem!_map' | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited γ] {f : α → β → γ} {k : α} (h : t.WF),
(Std.TreeMap.Raw.map f t)[k]! = (Option.pmap (fun v h => f (t.getKey k h) v) t[k]? ⋯).get! | Variant of `getElem!_map` that holds without `LawfulEqCmp`. | true |
BoxIntegral.integral_neg | Mathlib.Analysis.BoxIntegral.Basic | ∀ {ι : Type u} {E : Type v} {F : Type w} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {I : BoxIntegral.Box ι} [inst_4 : Fintype ι]
{l : BoxIntegral.IntegrationParams} {f : (ι → ℝ) → E} {vol : BoxIntegral.BoxAdditiveMap ι (E →L[ℝ] F) ⊤},
BoxInt... | null | true |
Algebra.algebraMapSubmonoid_powers | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {S : Type u_4} [inst_1 : Semiring S] [inst_2 : Algebra R S] (r : R),
Algebra.algebraMapSubmonoid S (Submonoid.powers r) = Submonoid.powers ((algebraMap R S) r) | null | true |
Real.ofDigits_nonneg | Mathlib.Analysis.Real.OfDigits | ∀ {b : ℕ} (digits : ℕ → Fin b), 0 ≤ Real.ofDigits digits | null | true |
NonUnitalSubring.ofClass._proof_1 | Mathlib.RingTheory.NonUnitalSubring.Defs | ∀ {S : Type u_2} {R : Type u_1} [inst : NonUnitalNonAssocRing R] [inst_1 : SetLike S R] [NonUnitalSubringClass S R]
(s : S) {a b : R}, a ∈ s → b ∈ s → a + b ∈ s | null | false |
Lean.Compiler.LCNF.LitValue.str.sizeOf_spec | Lean.Compiler.LCNF.Basic | ∀ (val : String), sizeOf (Lean.Compiler.LCNF.LitValue.str val) = 1 + sizeOf val | null | true |
Lean.Lsp.instFromJsonStaticRegistrationOptions.fromJson | Lean.Data.Lsp.Basic | Lean.Json → Except String Lean.Lsp.StaticRegistrationOptions | null | true |
Lean.Elab.Do.EffectForwarder._sizeOf_1 | Lean.Elab.Do.Control | Lean.Elab.Do.EffectForwarder → ℕ | null | false |
_private.Mathlib.Algebra.MvPolynomial.Basic.0.MvPolynomial.monomial_eq._simp_1_1 | Mathlib.Algebra.MvPolynomial.Basic | ∀ {R : Type u} {σ : Type u_1} [inst : CommSemiring R] {α : Type u_2} {β : Type u_3} [inst_1 : Zero β] (f : α →₀ β)
(g : α → β → σ →₀ ℕ) (a : R),
(MvPolynomial.C a * f.prod fun a b => (MvPolynomial.monomial (g a b)) 1) = (MvPolynomial.monomial (f.sum g)) a | null | false |
DifferentiableOn.hasDerivAt | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
DifferentiableOn 𝕜 f s → s ∈ nhds x → HasDerivAt f (deriv f x) x | null | true |
Aesop.UnsafeQueueEntry.postponedSafeRule.elim | Aesop.Tree.UnsafeQueue | {motive : Aesop.UnsafeQueueEntry → Sort u} →
(t : Aesop.UnsafeQueueEntry) →
t.ctorIdx = 1 → ((r : Aesop.PostponedSafeRule) → motive (Aesop.UnsafeQueueEntry.postponedSafeRule r)) → motive t | null | false |
_aux_Init_Notation___macroRules_termIfLet_1 | Init.Notation | Lean.Macro | null | false |
MonomialOrder.sPolynomial_def | Mathlib.RingTheory.MvPolynomial.MonomialOrder | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] (f g : MvPolynomial σ R),
m.sPolynomial f g =
(MvPolynomial.monomial (m.degree f ⊔ m.degree g - m.degree f)) (m.leadingCoeff g) * f -
(MvPolynomial.monomial (m.degree f ⊔ m.degree g - m.degree g)) (m.leadingCoeff f) * g | null | true |
Flag.instGradeOrderSubtypeMem._proof_1 | Mathlib.Order.Grade | ∀ {α : Type u_1} [inst : PartialOrder α] (s : Flag α), StrictMono Subtype.val | null | false |
SemiRingCat.Hom._mkInternal.inj | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : SemiRingCat} {hom' hom'_1 : ↑R →+* ↑S}, { hom' := hom' } = { hom' := hom'_1 } → hom' = hom'_1 | null | false |
Lean.Syntax.getTrailingTailPos? | Init.Meta.Defs | Lean.Syntax → optParam Bool false → Option String.Pos.Raw | Finds the tail position of the trailing whitespace of the first `SourceInfo` from the back of `stx`.
If no `SourceInfo` can be found or the first `SourceInfo` from the back of `stx` contains
no trailing whitespace and lacks a tail position, the result is `none`.
| true |
Module.finrank_of_bijective_toSpanSingleton | Mathlib.LinearAlgebra.Dimension.StrongRankCondition | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [StrongRankCondition R]
{x : M}, Function.Bijective ⇑(LinearMap.toSpanSingleton R M x) → Module.finrank R M = 1 | null | true |
_private.Mathlib.Geometry.Euclidean.Angle.Incenter.0.Affine.Triangle.two_mul_angle_excenter_singleton_eq_angle_add_pi._simp_1_1 | Mathlib.Geometry.Euclidean.Angle.Incenter | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | null | false |
List.get._proof_1 | Init.Prelude | ∀ {α : Type u_1} (head : α) (as : List α) (i : ℕ), i.succ < (head :: as).length → i.succ ≤ as.length | null | false |
IndiscreteTopology.of_forall_nnnorm_eq_zero' | Mathlib.Analysis.Normed.Group.Basic | ∀ {E : Type u_4} [inst : SeminormedGroup E], (∀ (x : E), ‖x‖₊ = 0) → IndiscreteTopology E | **Alias** of the reverse direction of `indiscreteTopology_iff_forall_nnnorm_eq_zero'`. | true |
_private.Mathlib.Algebra.Lie.Nilpotent.0.LieModule.instMaxNilpotentSubmoduleIsNilpotent._simp_1 | Mathlib.Algebra.Lie.Nilpotent | ∀ {α : Type u} {a : α} {p : α → Prop}, (a ∈ {x | p x}) = p a | null | false |
EquivLike.inv_apply_eq | Mathlib.Basic.FunLike.Equiv | ∀ {E : Sort u_1} {α : Sort u_3} {β : Sort u_4} [inst : EquivLike E α β] {e : E} {b : β} {a : α},
EquivLike.inv e b = a ↔ b = e a | null | true |
Stream'.nats | Mathlib.Data.Stream.Defs | Stream' ℕ | The stream of natural numbers: `Stream'.get n Stream'.nats = n`. | true |
SimpleGraph.Walk.mapToSubgraph.eq_def | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} {u v : V} (x : G.Walk u v),
x.mapToSubgraph =
match v, x with
| .(u), SimpleGraph.Walk.nil => SimpleGraph.Walk.nil
| v, SimpleGraph.Walk.cons h p =>
have h_1 := ⋯;
have h_2 := h_1;
SimpleGraph.Walk.cons h_2 (SimpleGraph.Walk.map (SimpleGraph.Subgraph.in... | null | true |
OrderIso.mapSetOfPredMaximal._proof_2 | Mathlib.Order.Minimal | ∀ {α : Type u_2} {β : Type u_1} [inst : Preorder α] [inst_1 : Preorder β] {s : Set α} {t : Set β} (f : ↑s ≃o ↑t)
(x : ↑{x | Maximal (fun x => x ∈ s) x}), Maximal (fun x => x ∈ t) ↑(f ⟨↑x, ⋯⟩) | null | false |
Std.TreeMap.Raw.getKeyLED | Std.Data.TreeMap.Raw.Basic | {α : Type u} → {β : Type v} → {cmp : α → α → Ordering} → Std.TreeMap.Raw α β cmp → α → α → α | Tries to retrieve the largest key that is less than or equal to the
given key, returning `fallback` if no such key exists.
| true |
DiffeologicalSpace.recOn | Mathlib.Geometry.Diffeology.Basic | {X : Type u_1} →
{motive : DiffeologicalSpace X → Sort u} →
(t : DiffeologicalSpace X) →
((plots : (n : ℕ) → Set (EuclideanSpace ℝ (Fin n) → X)) →
(constant_plots : ∀ {n : ℕ} (x : X), (fun x_1 => x) ∈ plots n) →
(plot_reparam :
∀ {n m : ℕ} {p : EuclideanSpace ℝ (Fin m) ... | null | false |
GenContFract.s | Mathlib.Algebra.ContinuedFractions.Basic | {α : Type u_1} → GenContFract α → Stream'.Seq (GenContFract.Pair α) | Sequence of partial numerator and denominator pairs. | true |
VectorBundleCore.inCoordinates_eq | Mathlib.Topology.VectorBundle.Basic | ∀ {B : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup F] [inst_1 : TopologicalSpace B] {𝕜₁ : Type u_5}
{𝕜₂ : Type u_6} [inst_2 : NontriviallyNormedField 𝕜₁] [inst_3 : NontriviallyNormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂}
{B' : Type u_7} [inst_4 : TopologicalSpace B'] [inst_5 : NormedSpace 𝕜₁ F] {F' : Type u_8}
... | Rewrite `ContinuousLinearMap.inCoordinates` in a `VectorBundleCore`. | true |
CategoryTheory.GrothendieckTopology.Cover.Relation.ext_iff | Mathlib.CategoryTheory.Sites.Grothendieck | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {X : C} {J : CategoryTheory.GrothendieckTopology C}
{S : J.Cover X} {x y : S.Relation}, x = y ↔ x.fst = y.fst ∧ x.snd = y.snd ∧ x.r ≍ y.r | null | true |
FractionalIdeal.coeFun_mapEquiv | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] (g : P ≃ₐ[R] P'),
⇑(FractionalIdeal.mapEquiv g) = FractionalIdeal.map ↑g | null | true |
PiTensorProduct.liftAlgHom_apply | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R : Type u_3} {A : ι → Type u_4} [inst : CommSemiring R] [inst_1 : (i : ι) → Semiring (A i)]
[inst_2 : (i : ι) → Algebra R (A i)] {S : Type u_5} [inst_3 : Semiring S] [inst_4 : Algebra R S]
(f : MultilinearMap R A S) (one : f 1 = 1) (mul : ∀ (x y : (i : ι) → A i), f (x * y) = f x * f y)
(a : PiT... | null | true |
Lean.Elab.Info.ofDocElabInfo | Lean.Elab.InfoTree.Types | Lean.Elab.DocElabInfo → Lean.Elab.Info | null | true |
Std.ExtDTreeMap.get?_union_of_not_mem_right | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₂ → (t₁ ∪ t₂).get? k = t₁.get? k | null | true |
_private.Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities.0.MvPolynomial.NewtonIdentities.pairMap_mem_pairs | Mathlib.RingTheory.MvPolynomial.Symmetric.NewtonIdentities | ∀ (σ : Type u_1) [inst : DecidableEq σ] [inst_1 : Fintype σ] {k : ℕ},
∀ t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k,
MvPolynomial.NewtonIdentities.pairMap✝ σ t ∈ MvPolynomial.NewtonIdentities.pairs✝ σ k | null | true |
Cycle.Chain.nil._simp_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} (r : α → α → Prop), Cycle.Chain r Cycle.nil = True | null | false |
FirstOrder.Language.Theory.ModelType.leftStructure | Mathlib.ModelTheory.Bundled | {L : FirstOrder.Language} → {L' : FirstOrder.Language} → {T : (L.sum L').Theory} → (M : T.ModelType) → L.Structure ↑M | null | true |
Lean.Lsp.instToJsonLeanDiagnosticTag | Lean.Data.Lsp.Diagnostics | Lean.ToJson Lean.Lsp.LeanDiagnosticTag | null | true |
_private.Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis.0.AlgebraicIndependent.matroid_spanning_iff._simp_1_7 | Mathlib.RingTheory.AlgebraicIndependent.TranscendenceBasis | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] [inst_3 : IsDomain R]
{x : S}, (x ∈ Subalgebra.algebraicClosure R S) = IsAlgebraic R x | null | false |
RCLike.cauSeqIm | Mathlib.Analysis.RCLike.Basic | {K : Type u_1} → [inst : RCLike K] → CauSeq K norm → CauSeq ℝ abs | The imaginary part of a K Cauchy sequence, as a real Cauchy sequence. | true |
Mathlib.Tactic.Module.matchScalarsAux | Mathlib.Tactic.Module | Lean.MVarId → Mathlib.Tactic.AtomM (List Lean.MVarId) | Given a goal which is an equality in a type `M` (with `M` an `AddCommMonoid`), parse the LHS and
RHS of the goal as linear combinations of `M`-atoms over some semiring `R`, and reduce the goal to
the respective equalities of the `R`-coefficients of each atom.
This is an auxiliary function which produces slightly awkwa... | true |
Metric.closedBall_disjoint_closedBall | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x y : α} {δ ε : ℝ},
δ + ε < dist x y → Disjoint (Metric.closedBall x δ) (Metric.closedBall y ε) | null | true |
Batteries.Tactic.instNonemptyCache | Batteries.Util.Cache | ∀ {α : Type}, Nonempty (Batteries.Tactic.Cache α) | null | true |
ImportGraph.Widget.CopyDisplay.noConfusionType | ImportGraph.Widget.Copy | Sort u → ImportGraph.Widget.CopyDisplay → ImportGraph.Widget.CopyDisplay → Sort u | null | false |
Fin.rev_lt_rev._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {i j : Fin n}, (i.rev < j.rev) = (j < i) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.