name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Monotone.limsup_nhdsGT_eq_iInf₂ | Mathlib.Topology.Order.LiminfLimsup | ∀ {α : Type u_2} {β : Type u_3} [inst : LinearOrder α] [inst_1 : TopologicalSpace α] [OrderTopology α]
[DenselyOrdered α] [inst_4 : CompleteLattice β] {f : α → β} [NoMaxOrder α],
Monotone f → ∀ (a : α), Filter.limsup f (nhdsWithin a (Set.Ioi a)) = ⨅ r, ⨅ (_ : r > a), f r | null | true |
MvPolynomial.exists_fin_left_rename | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_4} [inst : CommSemiring R] (p : MvPolynomial (σ ⊕ τ) R),
∃ n f, ∃ (_ : Function.Injective f), ∃ q, p = (MvPolynomial.rename (Sum.map f id)) q | Every polynomial in `σ ⊕ τ` is a polynomial in finitely many of the variables from `σ` and
all of the variables from `τ`.
Unlike `exists_fin_rename`, which reindexes the whole variable type along an injection
`Fin n → σ ⊕ τ`, the variables from `τ` are left untouched: only the left summand is
compacted. | true |
ENNReal.coe_one | Mathlib.Basic.ENNReal.Basic | ↑1 = 1 | null | true |
FirstOrder.Language.LHom.mem_substructureReduct._simp_1 | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} [inst : L.Structure M] {L' : FirstOrder.Language} [inst_1 : L'.Structure M]
(φ : L →ᴸ L') [inst_2 : φ.IsExpansionOn M] {x : M} {S : L'.Substructure M}, (x ∈ φ.substructureReduct S) = (x ∈ S) | null | false |
BitVec.toNat_ofFnBE | Batteries.Data.BitVec.Lemmas | ∀ {n : ℕ} (f : Fin n → Bool), (BitVec.ofFnBE f).toNat = Nat.ofBits (f ∘ Fin.rev) | null | true |
CategoryTheory.Functor.instIsLeftKanExtensionIdInvRightUnitorOfIsDense | Mathlib.CategoryTheory.Functor.KanExtension.Dense | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) [F.IsDense], (CategoryTheory.Functor.id D).IsLeftKanExtension F.rightUnitor.inv | null | true |
FunctionField.instFiniteDimensionalSubtypeMemIntermediateFieldOfIsAlgebraic | Mathlib.NumberTheory.FunctionField | ∀ {F : Type u_1} (K : Type u_2) [inst : Field F] [inst_1 : Field K] [inst_2 : Algebra (Polynomial F) K]
[inst_3 : FaithfulSMul (Polynomial F) K] [FunctionField F K] [inst_5 : Algebra F K] (E : IntermediateField F K)
[inst_6 : Algebra (Polynomial ↥E) K] [FaithfulSMul (Polynomial ↥E) K] [IsScalarTower (Polynomial F) ... | Let `K` be a function field over `F`. If `E` is an algebraic extension of `F` which is
contained in `K` then it is finite over `F`. | true |
Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.ctorIdx | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Lean.Meta.Grind.Arith.CommRing.DiseqCnstr → ℕ | null | false |
CategoryTheory.Functor.Monoidal.tensorObj_map | Mathlib.CategoryTheory.Monoidal.Cartesian.FunctorCategory | ∀ {J : Type u_1} {C : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} J]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] [inst_2 : CategoryTheory.CartesianMonoidalCategory C]
(F₁ F₂ : CategoryTheory.Functor J C) {j j' : J} (f : j ⟶ j'),
(CategoryTheory.MonoidalCategoryStruct.tensorObj F₁ F₂).map f =
Cate... | null | true |
Algebra.IsStandardSmoothOfRelativeDimension.localization_away | Mathlib.RingTheory.Smooth.StandardSmooth | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (r : R)
[IsLocalization.Away r S], Algebra.IsStandardSmoothOfRelativeDimension 0 R S | null | true |
PresentedAddMonoid.mk.eq_1 | Mathlib.Algebra.PresentedMonoid.Basic | ∀ {α : Type u_1} (rels : FreeAddMonoid α → FreeAddMonoid α → Prop),
PresentedAddMonoid.mk rels = { toFun := Quotient.mk (addConGen rels).toSetoid, map_zero' := ⋯, map_add' := ⋯ } | null | true |
TopologicalSpace.NonemptyCompacts.continuous_toCompacts | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α], Continuous TopologicalSpace.NonemptyCompacts.toCompacts | null | true |
Lean.DeclarationRange._sizeOf_inst | Lean.Data.DeclarationRange | SizeOf Lean.DeclarationRange | null | false |
Lean.Parser.Term.suffices.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
UInt64.toUInt8_toUInt16 | Init.Data.UInt.Lemmas | ∀ (n : UInt64), n.toUInt16.toUInt8 = n.toUInt8 | null | true |
AddCommMonoid.primaryComponent.disjoint | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} [inst : AddCommMonoid G] {p : ℕ} [hp : Fact (Nat.Prime p)] {p' : ℕ} [hp' : Fact (Nat.Prime p')],
p ≠ p' → Disjoint (AddCommMonoid.primaryComponent G p) (AddCommMonoid.primaryComponent G p') | The `p`- and `q`-primary components are disjoint for `p ≠ q`. | true |
sectionOfRetractionKerToTensorAux_prop | Mathlib.RingTheory.Smooth.Kaehler | ∀ {R : Type u_1} {P : Type u_2} {S : Type u_3} [inst : CommRing R] [inst_1 : CommRing P] [inst_2 : CommRing S]
[inst_3 : Algebra R P] [inst_4 : Algebra P S] (l : TensorProduct P S Ω[P⁄R] →ₗ[P] ↥(RingHom.ker (algebraMap P S))),
l ∘ₗ KaehlerDifferential.kerToTensor R P S = LinearMap.id →
∀ (x y : P),
(algeb... | null | true |
OneHom.withBotMap_apply | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {M : Type u_1} {N : Type u_2} [inst : One M] [inst_1 : One N] (f : OneHom M N), ⇑f.withBotMap = WithBot.map ⇑f | null | true |
CategoryTheory.Limits.BinaryBicone.op._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (b : CategoryTheory.Limits.BinaryBicone P Q),
CategoryTheory.CategoryStruct.comp b.fst.op b.inl.op = CategoryTheory.CategoryStruct.id (Opposite.op P) | null | false |
CategoryTheory.isFiltered_op_iff_isCofiltered | Mathlib.CategoryTheory.Filtered.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C], CategoryTheory.IsFiltered Cᵒᵖ ↔ CategoryTheory.IsCofiltered C | null | true |
IsRiemannianManifold.out | Mathlib.Geometry.Manifold.Riemannian.Basic | ∀ {E : Type u_1} {inst : NormedAddCommGroup E} {inst_1 : NormedSpace ℝ E} {H : Type u_2} {inst_2 : TopologicalSpace H}
{I : ModelWithCorners ℝ E H} {M : Type u_3} {inst_3 : TopologicalSpace M} {inst_4 : PseudoEMetricSpace M}
{inst_5 : ChartedSpace H M} {inst_6 : Bundle.RiemannianBundle fun x => TangentSpace I x}
... | null | true |
Lean.Meta.Grind.Arith.Linear.instHashablePoly_lean | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Hashable Lean.Grind.Linarith.Poly | null | true |
_private.Mathlib.RingTheory.Extension.Basic.0.Algebra.Extension.Cotangent.map_ker_of_surjective._simp_1_5 | Mathlib.RingTheory.Extension.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] {P : Algebra.Extension R S}
(x y : ↥P.ker), (Algebra.Extension.Cotangent.mk x = Algebra.Extension.Cotangent.mk y) = (↑x - ↑y ∈ P.ker ^ 2) | null | false |
_private.Mathlib.Data.Sum.Basic.0.Sum.LiftRel.exists_of_isLeft_left._proof_1_1 | Mathlib.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} {δ : Type u_4} {r : α → γ → Prop} {s : β → δ → Prop} {x : α ⊕ β}
{y : γ ⊕ δ}, Sum.LiftRel r s x y → x.isLeft = true → ∃ a c, r a c ∧ x = Sum.inl a ∧ y = Sum.inl c | null | false |
VonNeumannAlgebra.commutant_commutant | Mathlib.Analysis.VonNeumannAlgebra.Basic | ∀ {H : Type u} [inst : NormedAddCommGroup H] [inst_1 : InnerProductSpace ℂ H] [inst_2 : CompleteSpace H]
(S : VonNeumannAlgebra H), S.commutant.commutant = S | null | true |
Module.finrank_dvd_finrank_left | Mathlib.LinearAlgebra.Dimension.Free | ∀ (F : Type u) (K : Type v) (A : Type w) [inst : Semiring F] [inst_1 : Semiring K] [inst_2 : AddCommMonoid A]
[inst_3 : Module F K] [inst_4 : Module K A] [inst_5 : Module F A] [IsScalarTower F K A] [StrongRankCondition F]
[StrongRankCondition K] [Module.Free F K] [Module.Free K A], Module.finrank K A ∣ Module.finra... | null | true |
Batteries.Tactic.DeclCache.recOn | Batteries.Util.Cache | {α : Type} →
{motive : Batteries.Tactic.DeclCache α → Sort u} →
(t : Batteries.Tactic.DeclCache α) →
((cache : Batteries.Tactic.Cache α) →
(addDecl addLibraryDecl : Lean.Name → Lean.ConstantInfo → α → Lean.MetaM α) →
motive { cache := cache, addDecl := addDecl, addLibraryDecl := addLib... | null | false |
Vector.extract_zipWith | Init.Data.Vector.Zip | ∀ {α : Type u_1} {α_1 : Type u_2} {α_2 : Type u_3} {f : α → α_1 → α_2} {n : ℕ} {as : Vector α n} {bs : Vector α_1 n}
{i j : ℕ}, (Vector.zipWith f as bs).extract i j = Vector.zipWith f (as.extract i j) (bs.extract i j) | null | true |
_private.Init.Data.Array.InsertIdx.0.Array.getElem_insertIdx._proof_1 | Init.Data.Array.InsertIdx | ∀ {α : Type u_1} {xs : Array α} {i k : ℕ}, i ≤ xs.size → k < i → k < xs.size + 1 → ¬k < xs.size → False | null | false |
_private.Mathlib.Data.List.Nodup.0.List.Nodup.eq_of_head_mem_of_suffix._proof_1_7 | Mathlib.Data.List.Nodup | ∀ {α : Type u_1} (w : List α), ¬w.isEmpty = true → 0 < w.length | null | false |
CategoryTheory.InjectiveResolution.kernelFork.eq_1 | Mathlib.CategoryTheory.Preadditive.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (I : CategoryTheory.InjectiveResolution Z),
I.kernelFork = CategoryTheory.Limits.KernelFork.ofι (I.ι.f 0) ⋯ | null | true |
_private.Lean.Util.OccursCheck.0.Lean.occursCheck.visitMVar | Lean.Util.OccursCheck | {m : Type → Type} →
[Monad m] → [Lean.MonadMCtx m] → Lean.MVarId → Lean.MVarId → ExceptT Unit (StateT Lean.ExprSet m) Unit | null | true |
Order.height_nat | Mathlib.Order.KrullDimension | ∀ (n : ℕ), Order.height n = ↑n | null | true |
TensorProduct.finsuppScalarLeft._proof_3 | Mathlib.LinearAlgebra.DirectSum.Finsupp | ∀ (R : Type u_1) [inst : CommSemiring R], RingHomInvPair (RingHom.id R) (RingHom.id R) | null | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_setWidth._proof_1_6 | Init.Data.BitVec.Lemmas | ∀ {n m i : ℕ}, ¬n ≤ m → ¬i < m → i + n - m < n → False | null | false |
CategoryTheory.AddMon.addMon | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → (self : CategoryTheory.AddMon C) → CategoryTheory.AddMonObj self.X | null | true |
CategoryTheory.Lax.OplaxTrans.vComp_naturality_comp | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Lax | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
{F G H : CategoryTheory.LaxFunctor B C} (η : CategoryTheory.Lax.OplaxTrans F G)
(θ : CategoryTheory.Lax.OplaxTrans G H) {a b c : B} (f : a ⟶ b) (g : b ⟶ c),
CategoryTheory.CategoryStruct.comp (CategoryTheory.... | null | true |
_private.Init.Data.String.Substring.0.Substring.Raw.commonPrefix.loop._unary._proof_3 | Init.Data.String.Substring | ∀ (s t : Substring.Raw) (spos tpos : String.Pos.Raw),
spos < s.stopPos ∧ tpos < t.stopPos →
s.stopPos.byteIdx - (String.Pos.Raw.next s.str spos).byteIdx < s.stopPos.byteIdx - spos.byteIdx | null | false |
Maximal.mono | Mathlib.Order.Minimal | ∀ {α : Type u_2} {P Q : α → Prop} {x : α} [inst : LE α], Maximal P x → Q ≤ P → Q x → Maximal Q x | null | true |
CategoryTheory.Cat.Hom₂.ext | Mathlib.CategoryTheory.Category.Cat | ∀ {C D : CategoryTheory.Cat} {F G : C ⟶ D} {η₁ η₂ : F ⟶ G}, η₁.toNatTrans = η₂.toNatTrans → η₁ = η₂ | null | true |
IsLocalRing.ResidueField.field._proof_15 | Mathlib.RingTheory.LocalRing.ResidueField.Defs | ∀ (R : Type u_1) [inst : CommRing R] [inst_1 : IsLocalRing R], (IsLocalRing.maximalIdeal R).IsMaximal | null | false |
_private.Mathlib.Tactic.Linter.MinImports.0.Mathlib.Linter.MinImports.minImportsLinter.match_4 | Mathlib.Tactic.Linter.MinImports | (motive : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog → Sort u_1) →
(x : Lean.TSyntax `Lean.Parser.Module.header × Lean.Parser.ModuleParserState × Lean.MessageLog) →
((impMods : Lean.TSyntax `Lean.Parser.Module.header) →
(snd : Lean.Parser.ModuleParserState × ... | null | false |
VectorBundleCore.mem_localTrivAt_baseSet | Mathlib.Topology.VectorBundle.Basic | ∀ {R : Type u_1} {B : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField R] [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace R F] [inst_3 : TopologicalSpace B] {ι : Type u_5} (Z : VectorBundleCore R B F ι) (b : B),
b ∈ (Z.localTrivAt b).baseSet | null | true |
Interval.canLift | Mathlib.Order.Interval.Basic | ∀ {α : Type u_1} [inst : LE α], CanLift (Interval α) (NonemptyInterval α) Interval.coe fun r => r ≠ ⊥ | null | true |
_private.Init.Data.Range.Polymorphic.Fin.0.Fin.instLawfulUpwardEnumerableLE._proof_6 | Init.Data.Range.Polymorphic.Fin | ∀ {n : ℕ} (x y : Fin n), ↑x ≤ ↑y → ↑x + (↑y - ↑x) < n ∧ ↑x + (↑y - ↑x) = ↑y | null | false |
UInt8.ofNatClamp_finVal | Init.Data.UInt.Lemmas | ∀ (n : Fin UInt8.size), UInt8.ofNatClamp ↑n = UInt8.ofFin n | null | true |
CategoryTheory.Sieve.functorPullback_functorPushforward_overForget | Mathlib.CategoryTheory.Sites.Over | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {Y : CategoryTheory.Over X}
(S : CategoryTheory.Sieve Y),
CategoryTheory.Sieve.functorPullback (CategoryTheory.Over.forget X)
(CategoryTheory.Sieve.functorPushforward (CategoryTheory.Over.forget X) S) =
S | null | true |
starLinearEquiv._proof_2 | Mathlib.Algebra.Star.Module | ∀ (R : Type u_2) {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : AddCommMonoid A]
[inst_3 : StarAddMonoid A] [inst_4 : Module R A] [StarModule R A] (r : R) (a : A), star (r • a) = star r • star a | null | false |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
... | null | false |
Std.ExtDTreeMap.instDecidableEqOfTransCmpOfLawfulEqCmpOfLawfulBEq | Std.Data.ExtDTreeMap.Basic | {α : Type u} →
{β : α → Type v} →
{cmp : α → α → Ordering} →
[Std.TransCmp cmp] →
[Std.LawfulEqCmp cmp] →
[inst : (k : α) → BEq (β k)] → [∀ (k : α), LawfulBEq (β k)] → DecidableEq (Std.ExtDTreeMap α β cmp) | null | true |
iteratedDerivWithin_congr_right_of_isOpen | Mathlib.Analysis.Calculus.IteratedDeriv.Defs | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {F : Type u_2} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (f : 𝕜 → F) (n : ℕ) {s t : Set 𝕜},
IsOpen s → IsOpen t → Set.EqOn (iteratedDerivWithin n f s) (iteratedDerivWithin n f t) (s ∩ t) | null | true |
AlgebraicGeometry.PresheafedSpace.GlueData.ι_isOpenEmbedding | Mathlib.Geometry.RingedSpace.PresheafedSpace.Gluing | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (D : AlgebraicGeometry.PresheafedSpace.GlueData C)
[inst_1 : CategoryTheory.Limits.HasLimits C] (i : D.J),
Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom (D.ι i).base) | null | true |
LinearEquiv.isometryOfInner.congr_simp | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
{E' : Type u_4} [inst_3 : SeminormedAddCommGroup E'] [inst_4 : InnerProductSpace 𝕜 E'] (f f_1 : E ≃ₗ[𝕜] E')
(e_f : f = f_1) (h : ∀ (x y : E), inner 𝕜 (f x) (f y) = inner 𝕜 x y), f.isometryOf... | null | true |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.Poly.leadCoeff.match_1.eq_1 | Init.Data.Int.Linear | ∀ (motive : Int.Internal.Linear.Poly → Sort u_1) (a : ℤ) (v : Int.Internal.Linear.Var) (p : Int.Internal.Linear.Poly)
(h_1 :
(a : ℤ) →
(v : Int.Internal.Linear.Var) → (p : Int.Internal.Linear.Poly) → motive (Int.Internal.Linear.Poly.add a v p))
(h_2 : (x : Int.Internal.Linear.Poly) → motive x),
(match I... | null | true |
norm_derivWithin_eq_norm_fderivWithin | 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 𝕜}, ‖derivWithin f s x‖ = ‖fderivWithin 𝕜 f s x‖ | null | true |
PartialEquiv.prod_trans | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} {η : Type u_5} {ε : Type u_6} (e : PartialEquiv α β)
(f : PartialEquiv β γ) (e' : PartialEquiv δ η) (f' : PartialEquiv η ε),
(e.prod e').trans (f.prod f') = (e.trans f).prod (e'.trans f') | null | true |
_private.Mathlib.Algebra.Lie.Free.0.«termLib.lift» | Mathlib.Algebra.Lie.Free | Lean.ParserDescr | null | true |
Lean.ExternEntry.adhoc.inj | Lean.Compiler.ExternAttr | ∀ {backend backend_1 : Lean.Name},
Lean.ExternEntry.adhoc backend = Lean.ExternEntry.adhoc backend_1 → backend = backend_1 | null | true |
MvPowerSeries.WithPiTopology.instT0Space | Mathlib.RingTheory.MvPowerSeries.PiTopology | ∀ {σ : Type u_1} {R : Type u_2} [inst : TopologicalSpace R] [T0Space R], T0Space (MvPowerSeries σ R) | `MvPowerSeries` on a `T0Space` form a `T0Space` | true |
Int8.ofBitVec_uInt8ToBitVec | Init.Data.SInt.Lemmas | ∀ (x : UInt8), Int8.ofBitVec x.toBitVec = x.toInt8 | null | true |
Perfection.instRing._proof_7 | Mathlib.RingTheory.Perfection | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [hp : Fact (Nat.Prime p)] [inst_1 : CharP R p],
autoParam (∀ (a b : Perfection R p), a - b = a + -b) SubNegMonoid.sub_eq_add_neg._autoParam | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.deleteVerts_adj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
OreLocalization.oreSetOfIsCancelMulZero | Mathlib.RingTheory.OreLocalization.OreSet | {R : Type u_1} →
[inst : MonoidWithZero R] →
[IsCancelMulZero R] →
{S : Submonoid R} →
(oreNum : R → ↥S → R) →
(oreDenom : R → ↥S → ↥S) →
(∀ (r : R) (s : ↥S), ↑(oreDenom r s) * r = oreNum r s * ↑s) → OreLocalization.OreSet S | Cancellability in monoids with zeros can act as a replacement for the `ore_right_cancel`
condition of an ore set. | true |
ChartedSpaceCore.mk.injEq | Mathlib.Geometry.Manifold.ChartedSpace | ∀ {H : Type u_4} [inst : TopologicalSpace H] {M : Type u_5} (atlas : Set (PartialEquiv M H))
(chartAt : M → PartialEquiv M H) (mem_chart_source : ∀ (x : M), x ∈ (chartAt x).source)
(chart_mem_atlas : ∀ (x : M), chartAt x ∈ atlas)
(open_source : ∀ (e e' : PartialEquiv M H), e ∈ atlas → e' ∈ atlas → IsOpen (e.symm.... | null | true |
_private.Mathlib.Tactic.TermCongr.0.Mathlib.Tactic.TermCongr.CongrResult.eq.match_1 | Mathlib.Tactic.TermCongr | (motive : Option (Mathlib.Tactic.TermCongr.CongrType → Lean.MetaM Lean.Expr) → Sort u_1) →
(x : Option (Mathlib.Tactic.TermCongr.CongrType → Lean.MetaM Lean.Expr)) →
((pf : Mathlib.Tactic.TermCongr.CongrType → Lean.MetaM Lean.Expr) → motive (some pf)) →
(Unit → motive none) → motive x | null | false |
Matrix.smul_mat_empty | Mathlib.LinearAlgebra.Matrix.Notation | ∀ {α : Type u} [inst : NonUnitalNonAssocSemiring α] {m' : Type u_1} (x : α) (A : Fin 0 → m' → α), x • A = ![] | null | true |
_private.Mathlib.AlgebraicGeometry.Morphisms.Preimmersion.0.AlgebraicGeometry.IsPreimmersion.instIsStableUnderBaseChangeScheme._simp_2 | Mathlib.AlgebraicGeometry.Morphisms.Preimmersion | ∀ {X Y Z : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (g : Y ⟶ Z) (x : ↥X),
g (f x) = (CategoryTheory.CategoryStruct.comp f g) x | null | false |
edist_star_star | Mathlib.Analysis.CStarAlgebra.Basic | ∀ {E : Type u_2} [inst : SeminormedAddCommGroup E] [inst_1 : StarAddMonoid E] [NormedStarGroup E] (x y : E),
edist (star x) (star y) = edist x y | null | true |
Fin.foldrM_congr | Init.Data.Fin.Fold | ∀ {m : Type u_1 → Type u_2} {α : Type u_1} [inst : Monad m] {n k : ℕ} (w : n = k) (f : Fin n → α → m α),
Fin.foldrM n f = Fin.foldrM k fun i => f (Fin.cast ⋯ i) | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastAdd.go_denote_eq | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Add | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (curr : ℕ) (hcurr : curr ≤ w)
(cin : aig.Ref) (s : aig.RefVec curr) (lhs rhs : aig.RefVec w) (assign : α → Bool) (lhsExpr rhsExpr : BitVec w),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := lhs.get idx hidx }⟧ = lh... | null | true |
AffineSubspace.topEquiv._proof_3 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ (k : Type u_2) (V : Type u_3) (P : Type u_1) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P] (x : ↥⊤) (x_1 : ↥⊤.direction), (Equiv.Set.univ P) (x_1 +ᵥ x) = (Equiv.Set.univ P) (x_1 +ᵥ x) | null | false |
Finsupp.neLocus_eq_empty | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N},
f.neLocus g = ∅ ↔ f = g | null | true |
Module.Invertible.finrank_eq_one | Mathlib.RingTheory.PicardGroup | ∀ (R : Type u) (M : Type v) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[Module.Invertible R M] [Module.Free R M], Module.finrank R M = 1 | null | true |
Aesop.nodeUnknownEmoji | Aesop.Tracing | String | null | true |
TopRep.V | Mathlib.RepresentationTheory.Continuous.TopRep | {k : Type u} →
{G : Type v} → [inst : Ring k] → [inst_1 : TopologicalSpace k] → [inst_2 : Monoid G] → TopRep k G → Type w | the underlying type of an object in `TopRep k G` | true |
_private.Mathlib.Algebra.BigOperators.Fin.0.Fin.partialProd_contractNth._simp_1_4 | Mathlib.Algebra.BigOperators.Fin | ∀ {n : ℕ} {a b : Fin n}, (a.castSucc < b.succ) = (a ≤ b) | null | false |
GroupWithZero.toDivisionMonoid | Mathlib.Algebra.GroupWithZero.Basic | {G₀ : Type u_2} → [GroupWithZero G₀] → DivisionMonoid G₀ | null | true |
EuclideanGeometry.left_ne_right_of_oangle_ne_zero | Mathlib.Geometry.Euclidean.Angle.Oriented.Affine | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] [hd2 : Fact (Module.finrank ℝ V = 2)] [inst_4 : Module.Oriented ℝ V (Fin 2)]
{p₁ p₂ p₃ : P}, EuclideanGeometry.oangle p₁ p₂ p₃ ≠ 0 → p₁ ≠ p₃ | If the angle between three points is nonzero, the first and third points are not equal. | true |
_private.Mathlib.Tactic.FunProp.Mor.0.Mathlib.Meta.FunProp.Mor.whnfPred.match_1 | Mathlib.Tactic.FunProp.Mor | (motive : Option Mathlib.Meta.FunProp.Mor.App → Sort u_1) →
(__do_lift : Option Mathlib.Meta.FunProp.Mor.App) →
((coe f x : Lean.Expr) → motive (some { coe := coe, fn := f, arg := x })) →
((x : Option Mathlib.Meta.FunProp.Mor.App) → motive x) → motive __do_lift | null | false |
Finset.card_smul_finset | Mathlib.Algebra.Group.Action.Pointwise.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : SMul α β] [IsLeftCancelSMul α β] [inst_2 : DecidableEq β] (a : α)
(s : Finset β), (a • s).card = s.card | null | true |
Filter.pi_inf_principal_univ_pi_neBot | Mathlib.Order.Filter.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} {f : (i : ι) → Filter (α i)} {s : (i : ι) → Set (α i)},
(Filter.pi f ⊓ Filter.principal (Set.univ.pi s)).NeBot ↔ ∀ (i : ι), (f i ⊓ Filter.principal (s i)).NeBot | null | true |
Matroid.ext_isBase | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}, M₁.E = M₂.E → (∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)) → M₁ = M₂ | null | true |
sup_compl_eq_top | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x : α} [inst : BooleanAlgebra α], x ⊔ xᶜ = ⊤ | null | true |
Submodule.restrictScalars_sup | Mathlib.Algebra.Module.Submodule.RestrictScalars | ∀ (S : Type u_1) {R : Type u_2} {M : Type u_3} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Semiring S]
[inst_3 : Module S M] [inst_4 : Module R M] [inst_5 : SMul S R] [inst_6 : IsScalarTower S R M] (s t : Submodule R M),
Submodule.restrictScalars S (s ⊔ t) = Submodule.restrictScalars S s ⊔ Submodule.re... | null | true |
AbsoluteValue.comp | Mathlib.Topology.Algebra.Ring.Basic | {R : Type u_1} →
{S : Type u_2} →
{T : Type u_3} →
[inst : Semiring T] →
[inst_1 : Semiring R] →
[inst_2 : Semiring S] →
[inst_3 : PartialOrder S] → AbsoluteValue R S → {f : T →+* R} → Function.Injective ⇑f → AbsoluteValue T S | Construct an absolute value on a semiring `T` from an absolute value on a semiring `R`
and an injective ring homomorphism `f : T →+* R` | true |
Module.subsingleton_of_localization_maximal | Mathlib.RingTheory.LocalProperties.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
(Mₚ : (P : Ideal R) → [P.IsMaximal] → Type u_5) [inst_3 : (P : Ideal R) → [inst : P.IsMaximal] → AddCommMonoid (Mₚ P)]
[inst_4 : (P : Ideal R) → [inst_4 : P.IsMaximal] → Module R (Mₚ P)]
(f : (P : Ideal R) → [... | null | true |
ISize.toInt8 | Init.Data.SInt.Basic | ISize → Int8 | Converts a word-sized signed integer to an 8-bit signed integer by truncating its bitvector representation.
This function is overridden at runtime with an efficient implementation.
| true |
_private.Init.Data.Range.Basic.0.Std.Legacy.Range.forIn'.loop._unary._proof_2 | Init.Data.Range.Basic | ∀ (range : Std.Legacy.Range) (i : ℕ),
(i - range.start) % range.step = 0 → range.start ≤ i → (i + range.step - range.start) % range.step = 0 | null | false |
_private.Mathlib.Algebra.Order.Group.Synonym.0.Lex.instIsCancelMul._proof_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : Mul α] [IsCancelMul α], IsCancelMul (Lex α) | null | false |
ENNReal.Tendsto.div_const | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_1} {f : Filter α} {m : α → ENNReal} {a b : ENNReal},
Filter.Tendsto m f (nhds a) → a ≠ 0 ∨ b ≠ 0 → Filter.Tendsto (fun x => m x / b) f (nhds (a / b)) | null | true |
AlgebraicGeometry.StructureSheaf.IsLocalization.to_stalk | Mathlib.AlgebraicGeometry.StructureSheaf | ∀ (R : Type u) [inst : CommRing R] (p : PrimeSpectrum R),
IsLocalization.AtPrime (↑((AlgebraicGeometry.Spec.structureSheaf R).presheaf.stalk p)) p.asIdeal | Stalk of the structure sheaf at a prime p as localization of R | true |
IsSepClosed.algebraMap_bijective | Mathlib.FieldTheory.IsSepClosed | ∀ (k : Type u) [inst : Field k] (K : Type v) [inst_1 : Field K] [IsSepClosed k] [inst_3 : Algebra k K]
[Algebra.IsSeparable k K], Function.Bijective ⇑(algebraMap k K) | null | true |
ApproximatesLinearOn.inverse_continuousOn | Mathlib.Analysis.Calculus.InverseFunctionTheorem.ApproximatesLinearOn | ∀ {𝕜 : 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 : E → F}
{f' : E ≃L[𝕜] F} {s : Set E} {c : NNReal} (hf : ApproximatesLinearOn f (↑f') s c)
(hc : Subsingle... | The inverse function is continuous on `f '' s`.
Use properties of `OpenPartialHomeomorph` instead. | true |
CategoryTheory.Functor.OplaxMonoidal.δ_of_cartesianMonoidalCategory | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.CartesianMonoidalCategory D]
(F : CategoryTheory.Functor C D) [inst_4 : F.OplaxMonoidal] (X Y : C),
CategoryTheory.... | null | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.recoverHereWithKeeping | Lean.DocString.Parser | Array Lean.Syntax → ℕ → Lean.Parser.ParserFn → Lean.Parser.ParserFn | null | true |
Lean.Meta.Grind.CongrKey.mk._flat_ctor | Lean.Meta.Tactic.Grind.Types | {enodes : Lean.Meta.Grind.ENodeMap} → Lean.Expr → Lean.Meta.Grind.CongrKey enodes | null | false |
CategoryTheory.GradedObject.hasMap_comp | Mathlib.CategoryTheory.GradedObject | ∀ {I : Type u_1} {J : Type u_2} {K : Type u_3} {C : Type u_4} [inst : CategoryTheory.Category.{v_1, u_4} C]
(X : CategoryTheory.GradedObject I C) (p : I → J) [inst_1 : X.HasMap p] (q : J → K) (r : I → K),
(∀ (i : I), q (p i) = r i) → ∀ [(X.mapObj p).HasMap q], X.HasMap r | null | true |
NzsNum.not._unsafe_rec | Mathlib.Data.Num.Bitwise | NzsNum → NzsNum | null | false |
Algebra.Extension.Hom.mk.noConfusion | Mathlib.RingTheory.Extension.Basic | {R : Type u} →
{S : Type v} →
{inst : CommRing R} →
{inst_1 : CommRing S} →
{inst_2 : Algebra R S} →
{P : Algebra.Extension R S} →
{R' : Type u_1} →
{S' : Type u_2} →
{inst_3 : CommRing R'} →
{inst_4 : CommRing S'} →
... | null | false |
Std.DTreeMap.Raw.isSome_minKey?_iff_isEmpty_eq_false | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → (t.minKey?.isSome = true ↔ t.isEmpty = false) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.