name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
TopCat.PrelocalPredicate.sheafify | Mathlib.Topology.Sheaves.LocalPredicate | {X : TopCat} → {T : ↑X → Type u_2} → TopCat.PrelocalPredicate T → TopCat.LocalPredicate T | Given a `P : PrelocalPredicate`, we can always construct a `LocalPredicate`
by asking that the condition from `P` holds locally near every point.
| true |
HasDerivWithinAt.cos | Mathlib.Analysis.SpecialFunctions.Trigonometric.Deriv | ∀ {f : ℝ → ℝ} {f' x : ℝ} {s : Set ℝ},
HasDerivWithinAt f f' s x → HasDerivWithinAt (fun x => Real.cos (f x)) (-Real.sin (f x) * f') s x | null | true |
AddMonoidAlgebra.infDegree_withTop_some_comp | Mathlib.Algebra.MonoidAlgebra.Degree | ∀ {R : Type u_1} {A : Type u_3} {T : Type u_4} [inst : Semiring R] [inst_1 : SemilatticeInf T] [inst_2 : OrderTop T]
{D : A → T} {s : AddMonoidAlgebra R A},
s.coeff.support.Nonempty → AddMonoidAlgebra.infDegree (WithTop.some ∘ D) s = ↑(AddMonoidAlgebra.infDegree D s) | null | true |
_private.Mathlib.CategoryTheory.Sites.Pretopology.0.CategoryTheory.Pretopology.instInfSet._simp_2 | Mathlib.CategoryTheory.Sites.Pretopology | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋂ i, s i) = ∀ (i : ι), x ∈ s i | null | false |
AlgCat.limitSemiring._proof_12 | Mathlib.Algebra.Category.AlgCat.Limits | ∀ {R : Type u_4} [inst : CommRing R] {J : Type u_3} [inst_1 : CategoryTheory.Category.{u_1, u_3} J]
(F : CategoryTheory.Functor J (AlgCat R))
[inst_2 : Small.{u_2, max u_3 u_2} ↑(F.comp (CategoryTheory.forget (AlgCat R))).sections]
(a b : (CategoryTheory.Limits.Types.Small.limitCone (F.comp (CategoryTheory.forget... | null | false |
_private.Init.Data.Int.Linear.0.Int.Internal.Linear.not_le_of_le'._proof_1_3 | Init.Data.Int.Linear | ∀ (ctx : Int.Internal.Linear.Context) (p₁ : Int.Internal.Linear.Poly) (a₂ : ℤ) (x₂ : Int.Internal.Linear.Var) (k : ℤ),
Int.Internal.Linear.Poly.denote ctx p₁ + -(a₂ * Int.Internal.Linear.Var.denote ctx x₂) ≤ k →
¬Int.Internal.Linear.Poly.denote ctx p₁ ≤ k + a₂ * Int.Internal.Linear.Var.denote ctx x₂ → False | null | false |
Std.Http.Headers.mk._flat_ctor | Std.Http.Data.Headers | Std.Internal.IndexMultiMap Std.Http.Header.Name Std.Http.Header.Value → Std.Http.Headers | null | false |
add_tsub_tsub_cancel | Mathlib.Algebra.Order.Sub.Unbundled.Basic | ∀ {α : Type u_1} [inst : AddCommSemigroup α] [inst_1 : PartialOrder α] [ExistsAddOfLE α] [AddLeftMono α]
[inst_4 : Sub α] [OrderedSub α] {a b c : α} [AddLeftReflectLE α], c ≤ a → a + b - (a - c) = b + c | null | true |
MeasureTheory.MeasurePreserving.integral_comp | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} {G : Type u_5} [inst : NormedAddCommGroup G] [inst_1 : NormedSpace ℝ G] {m : MeasurableSpace α}
{μ : MeasureTheory.Measure α} {β : Type u_6} {x : MeasurableSpace β} {f : α → β} {ν : MeasureTheory.Measure β},
MeasureTheory.MeasurePreserving f μ ν →
MeasurableEmbedding f → ∀ (g : β → G), ∫ (x : α... | null | true |
Decidable.iff_congr_right | Init.PropLemmas | ∀ {P Q R : Prop} [Decidable P] [Decidable Q] [Decidable R], ((P ↔ Q) ↔ (P ↔ R)) ↔ (Q ↔ R) | null | true |
Coalgebra.Quotient.instQuotientSubmodule._proof_4 | Mathlib.RingTheory.Coalgebra.Quotient | ∀ {R : Type u_1} {C : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup C] [inst_2 : Module R C] (I : Submodule R C),
SMulCommClass R R (TensorProduct R R (C ⧸ I)) | null | false |
_private.Mathlib.Algebra.Algebra.Spectrum.Basic.0.spectrum.«term↑ₐ_1» | Mathlib.Algebra.Algebra.Spectrum.Basic | Lean.ParserDescr | null | true |
Multiset.range.eq_1 | Mathlib.Data.Multiset.Range | ∀ (n : ℕ), Multiset.range n = ↑(List.range n) | null | true |
Algebra.algebraMapSubmonoid_le_comap | Mathlib.Algebra.Algebra.Hom | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (M : Submonoid R)
{B : Type w} [inst_3 : Semiring B] [inst_4 : Algebra R B] (f : A →ₐ[R] B),
Algebra.algebraMapSubmonoid A M ≤ Submonoid.comap f.toRingHom (Algebra.algebraMapSubmonoid B M) | null | true |
Mathlib.Tactic.Ring.Common.RingCompare.mk | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{BaseType : Q(«$α») → Type} →
({x y : Q(«$α»)} → BaseType x → BaseType y → Bool) →
({x y : Q(«$α»)} → BaseType x → BaseType y → Ordering) → Mathlib.Tactic.Ring.Common.RingCompare BaseType | null | true |
UInt16.and_assoc | Init.Data.UInt.Bitwise | ∀ (a b c : UInt16), a &&& b &&& c = a &&& (b &&& c) | null | true |
_private.Mathlib.NumberTheory.LSeries.ZMod.0.ZMod.LFunction_one_sub._simp_1_3 | Mathlib.NumberTheory.LSeries.ZMod | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
WithConv.toConv.injEq | Mathlib.Algebra.WithConv | ∀ {A : Sort u_1} (ofConv ofConv_1 : A), (WithConv.toConv ofConv = WithConv.toConv ofConv_1) = (ofConv = ofConv_1) | null | true |
BddAbove.isBoundedUnder_of_range | Mathlib.Order.Filter.IsBounded | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] {f : Filter β} {u : β → α},
BddAbove (Set.range u) → Filter.IsBoundedUnder (fun x1 x2 => x1 ≤ x2) f u | A bounded above function `u` is in particular eventually bounded above. | true |
intervalIntegrable_of_odd₀ | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] {f : ℝ → E},
(∀ (x : ℝ), -f x = f (-x)) →
(∀ (x : ℝ), 0 < x → IntervalIntegrable f MeasureTheory.volume 0 x) →
∀ {t : ℝ},
autoParam (‖f (min 0 t)‖ₑ ≠ ⊤) intervalIntegrable_of_odd₀._auto_1 →
IntervalIntegrable f MeasureTheory.volume 0 t | An odd function is interval integrable (with respect to the volume measure) on every interval
of the form `0..x` if it is interval integrable (with respect to the volume measure) on every
interval of the form `0..x`, for positive `x`.
See `intervalIntegrable_of_odd` for a stronger result. | true |
_private.Lean.Elab.PreDefinition.MkInhabitant.0.Lean.Elab.mkInhabitantForAux? | Lean.Elab.PreDefinition.MkInhabitant | Array Lean.Expr → Array Lean.Expr → Lean.Expr → Bool → Lean.MetaM (Option Lean.Expr) | Find an inhabitant while doing delta unfolding.
| true |
continuous_neg_iff._simp_1 | Mathlib.Topology.Algebra.Group.ContinuousInv | ∀ {G : Type u_1} {α : Type u_3} [inst : TopologicalSpace G] [inst_1 : InvolutiveNeg G] [ContinuousNeg G]
[inst_3 : TopologicalSpace α] {f : α → G}, Continuous (-f) = Continuous f | null | false |
Lean.Meta.Match.instInhabitedProblem.default | Lean.Meta.Match.Basic | Lean.Meta.Match.Problem | null | true |
Complex.I_ne_zero._simp_1 | Mathlib.Basic.Complex.Basic | (Complex.I = 0) = False | null | false |
Colex.instDivInvMonoid.eq_1 | Mathlib.Algebra.Order.Group.Synonym | ∀ {α : Type u_1} [inst : DivInvMonoid α],
Colex.instDivInvMonoid =
{ toMonoid := Colex.instMonoid, toInv := Colex.instInv, toDiv := Colex.instDiv, toZPow := ZPow.ofPow,
div_eq_mul_inv := ⋯, zpow_zero' := ⋯, zpow_succ' := ⋯, zpow_neg' := ⋯ } | null | true |
Array.setIfInBounds_append_left | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs ys : Array α} {i : ℕ} {x : α},
i < xs.size → (xs ++ ys).setIfInBounds i x = xs.setIfInBounds i x ++ ys | null | true |
Mathlib.Tactic.ITauto.instInhabitedAndKind | Mathlib.Tactic.ITauto | Inhabited Mathlib.Tactic.ITauto.AndKind | null | true |
Real.noConfusionType | Mathlib.Basic.Real.Basic | Sort u → ℝ → ℝ → Sort u | null | false |
genLoopEquivOfUnique._proof_7 | Mathlib.Topology.Homotopy.HomotopyGroup | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x : X} (N : Type u_2) [Unique N] (p : ↑(GenLoop N X x)),
(p fun x => 1) = x | null | false |
ProbabilityTheory.Kernel.isSFiniteKernel_prodMkRight_unit | Mathlib.Probability.Kernel.Composition.MapComap | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β},
ProbabilityTheory.IsSFiniteKernel (ProbabilityTheory.Kernel.prodMkRight Unit κ) ↔ ProbabilityTheory.IsSFiniteKernel κ | null | true |
IsSpectralMap.mk | Mathlib.Topology.Spectral.Hom | ∀ {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] {f : α → β},
Continuous f → (∀ ⦃s : Set β⦄, IsOpen s → IsCompact s → IsCompact (f ⁻¹' s)) → IsSpectralMap f | null | true |
ExceptT.pure | Init.Control.Except | {ε : Type u} → {m : Type u → Type v} → [Monad m] → {α : Type u} → α → ExceptT ε m α | Returns the value `a` without throwing exceptions or having any other effect.
| true |
_private.Mathlib.Tactic.ClickSuggestions.Rewrite.0.Mathlib.Tactic.ClickSuggestions.RwLemma.try.match_12 | Mathlib.Tactic.ClickSuggestions.Rewrite | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(x : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (e : Lean.Expr) → motive (fst, fst_1, e)) → motive x | null | false |
hasStrictFDerivAt_apply | Mathlib.Analysis.Calculus.FDeriv.Prod | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {ι : Type u_6} {F' : ι → Type u_7}
[inst_1 : (i : ι) → NormedAddCommGroup (F' i)] [inst_2 : (i : ι) → NormedSpace 𝕜 (F' i)] (i : ι) (f : (i : ι) → F' i),
HasStrictFDerivAt (fun f => f i) (ContinuousLinearMap.proj i) f | null | true |
String.Pos.prev_induction | Init.Data.String.Termination | ∀ {s : String} {C : s.Pos → Prop} (p : s.Pos),
(∀ (x : s.Pos) (h : x ≠ s.startPos), C (x.prev h) → C x) → C s.startPos → C p | null | true |
Module.dualProdDualEquivDual | Mathlib.LinearAlgebra.Dual.Lemmas | (R : Type u_1) →
(M : Type u_2) →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
(M' : Type u_3) →
[inst_3 : AddCommMonoid M'] →
[inst_4 : Module R M'] → (Module.Dual R M × Module.Dual R M') ≃ₗ[R] Module.Dual R (M × M') | Taking duals distributes over products. | true |
_private.Init.Data.Array.Basic.0.Array.findSomeRevM?.find._unsafe_rec | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} →
{m : Type v → Type w} → [Monad m] → (α → m (Option β)) → (as : Array α) → (i : ℕ) → i ≤ as.size → m (Option β) | null | false |
Std.DHashMap.Raw.any_eq_true_iff_exists_contains_get | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : LawfulBEq α]
{p : (a : α) → β a → Bool}, m.WF → (m.any p = true ↔ ∃ a, ∃ (h : m.contains a = true), p a (m.get a h) = true) | null | true |
_private.Mathlib.CategoryTheory.NatIso.0.CategoryTheory.NatIso.cancel_natIso_inv_left._simp_1_1 | Mathlib.CategoryTheory.NatIso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : X ⟶ Y) [CategoryTheory.Epi f] {g h : Y ⟶ Z},
(CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp f h) = (g = h) | null | false |
IsRelPrime.add_mul_right_right_iff._simp_1 | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommRing R] {x y z : R}, IsRelPrime x (y + z * x) = IsRelPrime x y | null | false |
Mathlib.Tactic.Basify.elimExt | Mathlib.Tactic.Basify.Attr | Lean.SimpleScopedEnvExtension (Lean.Name × Mathlib.Tactic.Basify.ElimEntry)
(Lean.NameMap Mathlib.Tactic.Basify.ElimEntry) | The eliminators registered with `@[basify_elim]`, indexed by the head symbol of the type
they destruct. | true |
Std.Do.SPred.or_comm | Std.Do.SPred.DerivedLaws | ∀ {σs : List (Type u)} {P Q : Std.Do.SPred σs}, P ∨ Q ⊣⊢ₛ Q ∨ P | null | true |
dirSupClosedOn_Iic | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} {D : Set (Set α)} [inst : Preorder α] (a : α), DirSupClosedOn D (Set.Iic a) | null | true |
Module.Basis.addHaar_self | Mathlib.MeasureTheory.Measure.Haar.OfBasis | ∀ {ι : Type u_1} {E : Type u_3} [inst : Fintype ι] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace ℝ E]
[inst_3 : MeasurableSpace E] [inst_4 : BorelSpace E] (b : Module.Basis ι ℝ E), b.addHaar (parallelepiped ⇑b) = 1 | null | true |
Lean.Meta.Grind.Arith.Cutsat.DiseqCnstrProof.subst.noConfusion | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {P : Sort u} →
{x : Int.Internal.Linear.Var} →
{c₁ : Lean.Meta.Grind.Arith.Cutsat.EqCnstr} →
{c₂ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr} →
{x' : Int.Internal.Linear.Var} →
{c₁' : Lean.Meta.Grind.Arith.Cutsat.EqCnstr} →
{c₂' : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr} →
... | null | false |
Function.injective_of_isPartialInv_right | Mathlib.Logic.Function.Basic | ∀ {α : Type u_4} {β : Sort u_5} {f : α → β} {g : β → Option α},
Function.IsPartialInv f g → ∀ (x y : β), ∀ b ∈ g x, b ∈ g y → x = y | null | true |
Ideal.one_eq_top | Mathlib.RingTheory.Ideal.Operations | ∀ {R : Type u} [inst : Semiring R], 1 = ⊤ | null | true |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.ext_iff_isBase.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} {M₁ M₂ : Matroid α}
(motive : (M₁.E = M₂.E ∧ ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)) → Prop)
(x : M₁.E = M₂.E ∧ ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)),
(∀ (hE : M₁.E = M₂.E) (h : ∀ ⦃B : Set α⦄, B ⊆ M₁.E → (M₁.IsBase B ↔ M₂.IsBase B)), motive ⋯) → motive x | null | false |
CategoryTheory.CostructuredArrow.instEssSurjCompObjPostOfFull | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{B : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} B] (F : CategoryTheory.Functor B C)
(G : CategoryTheory.Functor C D) (S : C) [G.Full], (CategoryTheory.CostructuredArrow.post F G S).EssSur... | null | true |
Float.Model.UnpackedFloat.compare.fun_cases_unfolding | Batteries.Data.Float.Lemmas | ∀ (motive : Float.Model.UnpackedFloat → Float.Model.UnpackedFloat → Option Ordering → Prop),
(∀ (x : Float.Model.UnpackedFloat), motive Float.Model.UnpackedFloat.notANumber x none) →
(∀ (x : Float.Model.UnpackedFloat),
(x = Float.Model.UnpackedFloat.notANumber → False) → motive x Float.Model.UnpackedFloat... | null | true |
ContMDiffSection.coeFn_mk | Mathlib.Geometry.Manifold.VectorBundle.ContMDiffSection | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {F : Type u_5} [inst_6 : NormedAddCommG... | null | true |
NNReal.agm_eq_ciSup | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ {x y : NNReal}, x.agm y = ⨆ n, (x.agmSequences y n).1 | The AGM is also the supremum of the geometric means. | true |
CoalgCat.MonoidalCategory.inducingFunctorData._proof_7 | Mathlib.Algebra.Category.CoalgCat.Monoidal | ∀ (R : Type u_1) [inst : CommRing R] (X Y Z : CoalgCat R),
(CategoryTheory.forget₂ (CoalgCat R) (ModuleCat R)).map (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).hom =
(((CategoryTheory.Iso.refl
(CategoryTheory.MonoidalCategoryStruct.tensorObj
((CategoryTheory.forget₂ (Coal... | null | false |
ContinuousAlgHom.instContinuousMapClass | Mathlib.Topology.Algebra.Algebra | ∀ {R : Type u_1} [inst : CommSemiring R] {A : Type u_2} [inst_1 : Semiring A] [inst_2 : TopologicalSpace A]
{B : Type u_3} [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A] [inst_6 : Algebra R B],
ContinuousMapClass (A →A[R] B) A B | null | true |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.nlinarithGetSquareProofs.match_3 | Mathlib.Tactic.Linarith.Preprocessing | (motive : Lean.Expr × Bool → Sort u_1) →
(x : Lean.Expr × Bool) → ((e : Lean.Expr) → (is_sq : Bool) → motive (e, is_sq)) → motive x | null | false |
Std.DHashMap.Raw.Const.get!_alter_self | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β}
[inst_2 : EquivBEq α] [LawfulHashable α] {k : α} [inst_4 : Inhabited β] {f : Option β → Option β},
m.WF → Std.DHashMap.Raw.Const.get! (Std.DHashMap.Raw.Const.alter m k f) k = (f (Std.DHashMap.Raw.Const.get? m k)).ge... | null | true |
_private.Std.Data.Internal.List.Associative.0.Std.Internal.List.length_insertListIfNewUnit_le._simp_1_4 | Std.Data.Internal.List.Associative | ∀ (n : ℕ), (n ≤ n) = True | null | false |
Lean.Grind.AC.Expr.toSeq'.match_1.congr_eq_1 | Init.Grind.AC | ∀ (motive : Lean.Grind.AC.Expr → Sort u_1) (e : Lean.Grind.AC.Expr)
(h_1 : (x : Lean.Grind.AC.Var) → motive (Lean.Grind.AC.Expr.var x))
(h_2 : (a b : Lean.Grind.AC.Expr) → motive (a.op b)) (x : Lean.Grind.AC.Var),
e = Lean.Grind.AC.Expr.var x →
(match e with
| Lean.Grind.AC.Expr.var x => h_1 x
| a... | null | true |
_private.Init.Data.Array.Zip.0.Array.getElem?_zipWith.match_1.eq_1 | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} (motive : Option α → Option β → Sort u_3) (a : α) (b : β)
(h_1 : (a : α) → (b : β) → motive (some a) (some b)) (h_2 : (x : Option α) → (x_1 : Option β) → motive x x_1),
(match some a, some b with
| some a, some b => h_1 a b
| x, x_1 => h_2 x x_1) =
h_1 a b | null | true |
DirSupClosed.of_isEmpty | Mathlib.Order.DirSupClosed | ∀ {α : Type u_1} [inst : Preorder α] [IsEmpty α] {s : Set α}, DirSupClosed s | null | true |
Prod.indiscreteTopology | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] [h : IndiscreteTopology X]
[hY : IndiscreteTopology Y], IndiscreteTopology (X × Y) | null | true |
IsDedekindDomain.HeightOneSpectrum.mk.injEq | Mathlib.RingTheory.DedekindDomain.Ideal.Lemmas | ∀ {R : Type u_1} [inst : CommRing R] (asIdeal : Ideal R) (isPrime : asIdeal.IsPrime) (ne_bot : asIdeal ≠ ⊥)
(asIdeal_1 : Ideal R) (isPrime_1 : asIdeal_1.IsPrime) (ne_bot_1 : asIdeal_1 ≠ ⊥),
({ asIdeal := asIdeal, isPrime := isPrime, ne_bot := ne_bot } =
{ asIdeal := asIdeal_1, isPrime := isPrime_1, ne_bot := ... | null | true |
IO.FS.readBinFile | Init.System.IO | System.FilePath → IO ByteArray | Reads the entire contents of the binary file at the given path as an array of bytes.
| true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.edgeSet_subgraphOfAdj._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {α : Sort u_1} {a b : α}, (a = b) = (b = a) | null | false |
Std.ExtDTreeMap.keyAtIdx._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {cmp : α → α → Ordering} [Std.TransCmp cmp] (t : Std.ExtDTreeMap α β cmp) (n : ℕ)
(h : n < t.size) (x x_1 : Std.DTreeMap α β cmp) (x_2 : t = Std.ExtDTreeMap.mk x),
t = Std.ExtDTreeMap.mk x_1 → ∀ (h_1 : x.Equiv x_1), x.keyAtIdx n ⋯ = x_1.keyAtIdx n ⋯ | null | false |
Lean.Environment.PromiseCheckedResult._sizeOf_inst | Lean.Environment | SizeOf Lean.Environment.PromiseCheckedResult | null | false |
Module.End.mem_invtSubmodule_adjoint_iff | 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} {U : Submodule 𝕜 E},
U ∈ Module.End.invtSubmodule (LinearMap.adjoint T) ↔ Uᗮ ∈ Module.End.invtSubmodule T | The linear map version of `ContinuousLinearMap.mem_invtSubmodule_adjoint_iff`
in a finite-dimensional space. | true |
Mathlib.Notation3.matchForall | Mathlib.Util.Notation3 | Mathlib.Notation3.Matcher → (Lean.Expr → Mathlib.Notation3.Matcher) → Mathlib.Notation3.Matcher | Matches pi types. The name `n` should be unique, and `matchBody` should use `n`
as the `userName` of its fvar. | true |
CategoryTheory.Abelian.SpectralObject.dShortComplex_f | Mathlib.Algebra.Homology.SpectralObject.Homology | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.Category.{v_2, u_2} ι] (X : CategoryTheory.Abelian.SpectralObject C ι)
{i₀ i₁ i₂ i₃ i₄ i₅ i₆ i₇ : ι} (f₁ : i₀ ⟶ i₁) (f₂ : i₁ ⟶ i₂) (f₃ : i₂ ⟶ i₃) (f₄ : i₃ ⟶ i₄) (f₅ : i₄ ⟶ i₅)
... | null | true |
CategoryTheory.PreOneHypercover.IsStronglySheafFor.isLimitMultifork._proof_3 | Mathlib.CategoryTheory.Sites.Hypercover.SheafOfTypes | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {X : C} {E : CategoryTheory.PreOneHypercover X}
{F : CategoryTheory.Functor Cᵒᵖ (Type u_1)} (h : E.IsStronglySheafFor F) (s : (E.multicospanIndex F).sections),
(E.multifork F).toSections (h.amalgamate s.val ⋯) = s | null | false |
Matrix.reindexLinearEquiv._proof_2 | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_1} {n : Type u_2} {m' : Type u_4} {n' : Type u_5} (R : Type u_6) (A : Type u_3) [inst : Semiring R]
[inst_1 : AddCommMonoid A] [inst_2 : Module R A] (eₘ : m ≃ m') (eₙ : n ≃ n') (x : R) (x_1 : Matrix m n A),
(Matrix.reindexAddEquiv A eₘ eₙ).toFun (x • x_1) = (Matrix.reindexAddEquiv A eₘ eₙ).toFun (x • ... | null | false |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteAddGrpCatAddMonoidHomCarrier.eq_1 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteAddGrpCatAddMonoidHomCarrier =
{
forget₂ :=
{ obj := fun P => ↧↑P.toProfinite.toTop,
map := fun {X Y} f => AddGrpCat.ofHom (ProfiniteAddGrp.Hom.hom f).toAddMonoidHom,
map_id :=
Profin... | null | true |
_private.Mathlib.MeasureTheory.Function.LocallyIntegrable.0.MeasureTheory.LocallyIntegrableOn.norm.match_1_1 | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {X : Type u_1} {E : Type u_2} [inst : MeasurableSpace X] [inst_1 : TopologicalSpace X] [inst_2 : NormedAddCommGroup E]
{μ : MeasureTheory.Measure X} {s : Set X} {f : X → E} (t : X)
(motive : MeasureTheory.IntegrableAtFilter f (nhdsWithin t s) μ → Prop)
(x : MeasureTheory.IntegrableAtFilter f (nhdsWithin t s) μ)... | null | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.Operations.0.RKHS.Add'.kerFun_mem_orthogonal._simp_1_2 | Mathlib.Analysis.InnerProductSpace.Reproducing.Operations | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(x y z : E), inner 𝕜 x z + inner 𝕜 y z = inner 𝕜 (x + y) z | null | false |
CommRingCat.Colimits.Relation.left_distrib | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CommRingCat}
(x y z : CommRingCat.Colimits.Prequotient F),
CommRingCat.Colimits.Relation F (x.mul (y.add z)) ((x.mul y).add (x.mul z)) | null | true |
PrimeSpectrum.height_eq_orderHeight | Mathlib.RingTheory.Ideal.Height | ∀ {R : Type u_1} [inst : CommRing R] (p : PrimeSpectrum R), p.asIdeal.height = Order.height p | null | true |
Filter.Germ.instPow | Mathlib.Order.Filter.Germ.Basic | {α : Type u_1} → {l : Filter α} → {M : Type u_5} → {G : Type u_6} → [Pow G M] → Pow (l.Germ G) M | null | true |
CategoryTheory.Cat.FreeRefl.instUniqueHom | Mathlib.CategoryTheory.Category.ReflQuiv | (V : Type u_2) →
[inst : CategoryTheory.ReflQuiver V] →
[Unique V] → [(x y : V) → Unique (x ⟶ y)] → (x y : CategoryTheory.Cat.FreeRefl V) → Unique (x ⟶ y) | null | true |
LinearIndepOn.id_insert | Mathlib.LinearAlgebra.LinearIndependent.Lemmas | ∀ {K : Type u_3} {V : Type u} [inst : DivisionRing K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {s : Set V}
{x : V}, LinearIndepOn K id s → x ∉ Submodule.span K s → LinearIndepOn K id (insert x s) | null | true |
FreeAbelianGroup.support_of | Mathlib.Algebra.FreeAbelianGroup.Finsupp | ∀ {X : Type u_1} (x : X), (FreeAbelianGroup.of x).support = {x} | null | true |
Affine.Simplex.independent | Mathlib.LinearAlgebra.AffineSpace.Simplex.Basic | ∀ {k : Type u_1} {V : Type u_2} {P : Type u_5} [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[inst_3 : AddTorsor V P] {n : ℕ} (self : Affine.Simplex k P n), AffineIndependent k self.points | null | true |
OreLocalization.instCommGroupWithZeroNonZeroDivisors._proof_1 | Mathlib.RingTheory.OreLocalization.NonZeroDivisors | ∀ {R : Type u_1} [inst : CommMonoidWithZero R] [inst_1 : Nontrivial R]
[inst_2 : OreLocalization.OreSet (nonZeroDivisors R)] [inst_3 : NoZeroDivisors R]
(a b : OreLocalization (nonZeroDivisors R) R), a / b = a * b⁻¹ | null | false |
Std.HashMap.Equiv.symm | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashMap α β}, m₁.Equiv m₂ → m₂.Equiv m₁ | null | true |
Mathlib.Tactic.Ring.Common.ExtractCoeff._sizeOf_inst | Mathlib.Tactic.Ring.Common | (e : Q(ℕ)) → SizeOf (Mathlib.Tactic.Ring.Common.ExtractCoeff e) | null | false |
CategoryTheory.Limits.CreatesFiniteLimits.mk._flat_ctor | Mathlib.CategoryTheory.Limits.Preserves.Creates.Finite | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F : CategoryTheory.Functor C D} →
autoParam
((J : Type) →
[inst_2 : CategoryTheory.SmallCategory J] →
[CategoryTheo... | null | false |
_private.Init.Data.Nat.Bitwise.Lemmas.0.Nat.eq_0_of_lt | Init.Data.Nat.Bitwise.Lemmas | ∀ (x : ℕ), x < 2 ^ 0 ↔ x = 0 | null | true |
_private.Std.Sync.Channel.0.Std.CloseableChannel.Consumer.noConfusion | Std.Sync.Channel | {P : Sort u} →
{α : Type} →
{t : Std.CloseableChannel.Consumer✝ α} →
{α' : Type} →
{t' : Std.CloseableChannel.Consumer✝ α'} →
α = α' → t ≍ t' → Std.CloseableChannel.Consumer.noConfusionType✝ P t t' | null | false |
TensorProduct.quotTensorEquivQuotSMul._proof_1 | Mathlib.LinearAlgebra.TensorProduct.Quotient | ∀ {R : Type u_2} (M : Type u_1) [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (I : Ideal R),
Submodule.map (↑(TensorProduct.lid R M)) (TensorProduct.map (Submodule.subtype I) LinearMap.id).range = I • ⊤ | null | false |
List.forall₂_cons_left_iff | Mathlib.Data.List.Forall2 | ∀ {α : Type u_1} {β : Type u_2} {R : α → β → Prop} {a : α} {l : List α} {u : List β},
List.Forall₂ R (a :: l) u ↔ ∃ b u', R a b ∧ List.Forall₂ R l u' ∧ u = b :: u' | null | true |
Polynomial.expand_monomial | Mathlib.Algebra.Polynomial.Expand | ∀ {R : Type u} [inst : CommSemiring R] (p q : ℕ) (r : R),
(Polynomial.expand R p) ((Polynomial.monomial q) r) = (Polynomial.monomial (q * p)) r | null | true |
SFinKer.instDeterministicComul | Mathlib.Probability.Kernel.Category.SFinKer | ∀ {X : SFinKer}, CategoryTheory.Deterministic CategoryTheory.ComonObj.comul | null | true |
Matrix.isSymm_transpose_iff._simp_1 | Mathlib.LinearAlgebra.Matrix.Symmetric | ∀ {α : Type u_1} {n : Type u_3} {A : Matrix n n α}, A.transpose.IsSymm = A.IsSymm | null | false |
_private.Lean.Elab.PreDefinition.FixedParams.0.Lean.Elab.FixedParamPerm.instantiateLambda.go._f | Lean.Elab.PreDefinition.FixedParams | Array Lean.Expr →
(x : List (Option ℕ)) →
List.below (motive := fun x => Lean.Expr → Lean.MetaM Lean.Expr) x → Lean.Expr → Lean.MetaM Lean.Expr | null | false |
Std.Do.Spec.IterM.forIn_mapWithPostcondition | Std.Do.Triple.SpecLemmas | ∀ {α : Type u₁} {n : Type u₁ → Type u_1} {o : Type u₁ → Type u_2} {β₂ γ : Type u₁} {m : Type u₁ → Type u_3}
{β : Type u₁} {ps : Std.Do.PostShape} [inst : Monad m] [LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n]
[inst_4 : Monad o] [LawfulMonad o] [inst_6 : Std.Do.WPMonad o ps] [inst_7 : MonadLiftT m n] [LawfulMon... | null | true |
SimpleGraph.chromaticNumber_mono_of_hom | Mathlib.Combinatorics.SimpleGraph.Coloring.Vertex | ∀ {V : Type u} {G : SimpleGraph V} {V' : Type u_4} {G' : SimpleGraph V'} (f : G →g G'),
G.chromaticNumber ≤ G'.chromaticNumber | null | true |
NNReal.sqrt_pos_of_pos | Mathlib.Analysis.Real.Sqrt | ∀ {x : NNReal}, 0 < x → 0 < NNReal.sqrt x | **Alias** of the reverse direction of `NNReal.sqrt_pos`. | true |
FP.ofRatUp | Mathlib.Data.FP.Basic | [C : FP.FloatCfg] → ℚ → FP.Float | null | true |
Lean.Meta.Grind.SplitStatus._sizeOf_inst | Lean.Meta.Tactic.Grind.Split | SizeOf Lean.Meta.Grind.SplitStatus | null | false |
Lean.IR.modifyJPsM | Lean.Compiler.IR.Basic | {m : Type → Type} → [Monad m] → Array Lean.IR.FnBody → (Lean.IR.FnBody → m Lean.IR.FnBody) → m (Array Lean.IR.FnBody) | null | true |
MeasureTheory.lintegral_sum_measure | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {ι : Type u_4} (f : α → ENNReal) (μ : ι → MeasureTheory.Measure α),
∫⁻ (a : α), f a ∂MeasureTheory.Measure.sum μ = ∑' (i : ι), ∫⁻ (a : α), f a ∂μ i | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.