name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.MeasureTheory.Integral.CircleIntegral.0.circleIntegral.circleIntegral_congr_codiscreteWithin._simp_1_1 | Mathlib.MeasureTheory.Integral.CircleIntegral | ∀ {M₀ : Type u_1} [inst : MulZeroClass M₀] [IsLeftCancelMulZero M₀] {a b c : M₀}, (a * b = a * c) = (b = c ∨ a = 0) | null | false |
OrderIso.prodComm | Mathlib.Order.Hom.Basic | {α : Type u_2} → {β : Type u_3} → [inst : LE α] → [inst_1 : LE β] → α × β ≃o β × α | `Prod.swap` as an `OrderIso`. | true |
CategoryTheory.Functor.leftKanExtensionIsoFiberwiseColimit_hom_app | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_1} {D : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] (L : CategoryTheory.Functor C D) {H : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, u_3} H] (F : CategoryTheory.Functor C H)
[inst_3 : L.HasPointwiseLeftKanExtension F] [inst_4 : L.Has... | null | true |
floorDiv_one | Mathlib.Algebra.Order.Floor.Div | ∀ {α : Type u_2} {β : Type u_3} [inst : Semiring α] [inst_1 : PartialOrder α] [inst_2 : AddCommMonoid β]
[inst_3 : PartialOrder β] [inst_4 : MulActionWithZero α β] [inst_5 : FloorDiv α β] [IsOrderedRing α] [Nontrivial α]
(b : β), b ⌊/⌋ 1 = b | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Bipartite.0.SimpleGraph.IsBipartiteWith.edgeSetEmbeddingCompleteBipartiteGraph._proof_37 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} {s t : Set V} (a_1 : V × V), a_1.1 ∈ s → a_1.2 ∈ t → a_1.2 ∈ t | null | false |
Nat._aux_Mathlib_Algebra_Order_Floor_Defs___unexpand_Nat_floor_1 | Mathlib.Algebra.Order.Floor.Defs | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.Topology.Instances.Real.Lemmas.0.closure_ordConnected_inter_rat._simp_1_5 | Mathlib.Topology.Instances.Real.Lemmas | ∀ {α : Type u} [inst : AddCommGroup α] [inst_1 : LT α] [AddLeftStrictMono α] {a b c : α}, (a - b < c) = (a - c < b) | null | false |
IntermediateField.sInf_toSubalgebra | Mathlib.FieldTheory.IntermediateField.Adjoin.Defs | ∀ {F : Type u_1} [inst : Field F] {E : Type u_2} [inst_1 : Field E] [inst_2 : Algebra F E]
(S : Set (IntermediateField F E)), (sInf S).toSubalgebra = sInf (IntermediateField.toSubalgebra '' S) | null | true |
Lean.Grind.Linarith.zero_ne_one_of_charC_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (c : ℕ) (p : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.zero_ne_one_of_charC_cert c p =
(decide (↑c > 1) && p == Lean.Grind.Linarith.Poly.add 1 0 Lean.Grind.Linarith.Poly.nil) | null | true |
CochainComplex.HomComplex.Cochain.shift_units_smul | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexShift | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C] {R : Type u_1}
[inst_2 : Ring R] [inst_3 : CategoryTheory.Linear R C] {K L : CochainComplex C ℤ} {n : ℤ}
(γ : CochainComplex.HomComplex.Cochain K L n) (a : ℤ) (x : Rˣ), (x • γ).shift a = x • γ.shift a | null | true |
DistribSMul.mk.noConfusion | Mathlib.Algebra.GroupWithZero.Action.Defs | {M : Type u_12} →
{A : Type u_13} →
{inst : AddZeroClass A} →
{P : Sort u} →
{toSMulZeroClass : SMulZeroClass M A} →
{smul_add : ∀ (a : M) (x y : A), a • (x + y) = a • x + a • y} →
{toSMulZeroClass' : SMulZeroClass M A} →
{smul_add' : ∀ (a : M) (x y : A), a • (x +... | null | false |
List.take_take | Init.Data.List.Nat.TakeDrop | ∀ {α : Type u_1} {i j : ℕ} {l : List α}, List.take i (List.take j l) = List.take (min i j) l | null | true |
DifferentiableWithinAt.clm_comp | Mathlib.Analysis.Calculus.FDeriv.CompCLM | ∀ {𝕜 : 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] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {x : E} {s : Set E} {H : Type u_5}
... | null | true |
Nat.ModEq.listProd_one | Mathlib.Algebra.BigOperators.ModEq | ∀ {n : ℕ} {l : List ℕ}, (∀ x ∈ l, x ≡ 1 [MOD n]) → l.prod ≡ 1 [MOD n] | null | true |
eq_true_of_ne_false | Init.Data.Bool | ∀ {b : Bool}, b ≠ false → b = true | null | true |
DoubleCentralizer.nnnorm_def' | Mathlib.Analysis.CStarAlgebra.Multiplier | ∀ {𝕜 : Type u_1} {A : Type u_2} [inst : NontriviallyNormedField 𝕜] [inst_1 : NonUnitalNormedRing A]
[inst_2 : NormedSpace 𝕜 A] [inst_3 : SMulCommClass 𝕜 A A] [inst_4 : IsScalarTower 𝕜 A A] (a : DoubleCentralizer 𝕜 A),
‖a‖₊ = ‖DoubleCentralizer.toProdMulOppositeHom a‖₊ | null | true |
_private.Lean.Meta.Tactic.Grind.Inv.0.Lean.Meta.Grind.checkChild | Lean.Meta.Tactic.Grind.Inv | Lean.Expr → Lean.Expr → Lean.Meta.Grind.GoalM Bool | null | true |
Matrix.reindexLinearEquiv_mul | Mathlib.LinearAlgebra.Matrix.Reindex | ∀ {m : Type u_1} {n : Type u_2} {o : Type u_3} {m' : Type u_4} {n' : Type u_5} {o' : Type u_6} (R : Type u_9)
(A : Type u_10) [inst : Semiring R] [inst_1 : Semiring A] [inst_2 : Module R A] [inst_3 : Fintype n]
[inst_4 : Fintype n'] (eₘ : m ≃ m') (eₙ : n ≃ n') (eₒ : o ≃ o') (M : Matrix m n A) (N : Matrix n o A),
... | null | true |
Std.HashMap.Raw.getKeyD_insertManyIfNewUnit_list_of_not_mem_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m : Std.HashMap.Raw α Unit} [EquivBEq α] [LawfulHashable α],
m.WF →
∀ {l : List α} {k k' fallback : α},
(k == k') = true →
k ∉ m →
List.Pairwise (fun a b => (a == b) = false) l → k ∈ l → (m.insertManyIfNewUnit l).getKeyD k' fallback = k | null | true |
LinearMap.IsPosSemidef.add | Mathlib.LinearAlgebra.SesquilinearForm.Basic | ∀ {R : Type u_1} {M : Type u_5} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {I₁ : R →+* R}
[inst_3 : Preorder R] [AddLeftMono R] {B C : M →ₛₗ[I₁] M →ₗ[R] R},
B.IsPosSemidef → C.IsPosSemidef → (B + C).IsPosSemidef | null | true |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary.eq_def | Mathlib.Tactic.FieldSimp | ∀ {v : Lean.Level} {M : Q(Type v)} (iM : Q(CommGroupWithZero «$M»))
(_x : (_ : Mathlib.Tactic.FieldSimp.qNF M) ×' Mathlib.Tactic.FieldSimp.qNF M),
Mathlib.Tactic.FieldSimp.qNF.mkDivProof._unary iM _x =
PSigma.casesOn _x fun l₁ l₂ =>
match l₁, l₂ with
| [], l =>
have a := l.toNF;
q(⋯)... | null | false |
CategoryTheory.Oplax.LaxTrans.Hom.as | Mathlib.CategoryTheory.Bicategory.Modification.Oplax | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{C : Type u₂} →
[inst_1 : CategoryTheory.Bicategory C] →
{F G : CategoryTheory.OplaxFunctor B C} →
{η θ : F ⟶ G} → CategoryTheory.Oplax.LaxTrans.Hom η θ → CategoryTheory.Oplax.LaxTrans.Modification η θ | The underlying modification of lax transformations. | true |
CategoryTheory.Limits.FintypeCat.inclusion_preservesFiniteColimits | Mathlib.CategoryTheory.Limits.FintypeCat | CategoryTheory.Limits.PreservesFiniteColimits FintypeCat.incl | null | true |
Std.TreeMap.Raw.getElem!_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Inhabited β], t.WF → ∀ {k a : α} {v : β}, (t.insert k v)[a]! = if cmp k a = Ordering.eq then v else t[a]! | null | true |
MeasureTheory.integrableOn_iff_comap_subtypeVal | Mathlib.MeasureTheory.Integral.IntegrableOn | ∀ {α : Type u_1} {ε : Type u_3} {mα : MeasurableSpace α} {f : α → ε} {s : Set α} {μ : MeasureTheory.Measure α}
[inst : TopologicalSpace ε] [inst_1 : ContinuousENorm ε],
MeasurableSet s →
(MeasureTheory.IntegrableOn f s μ ↔
MeasureTheory.Integrable (f ∘ Subtype.val) (MeasureTheory.Measure.comap Subtype.val... | null | true |
instCommRingBDeRhamPlus._proof_12 | Mathlib.RingTheory.Perfectoid.BDeRham | ∀ (R : Type u_1) [inst : CommRing R] (p : ℕ) [inst_1 : Fact (Nat.Prime p)] [inst_2 : Fact ¬IsUnit ↑p]
[inst_3 : IsAdicComplete (Ideal.span {↑p}) R] (a b : BDeRhamPlus R p), a + b = b + a | null | false |
LieIdeal.mem_rootSet | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra] {I : LieIdeal K L}
{α : ↥LieSubalgebra.root}, α ∈ I.rootSet ↔ LieAlgebra.rootSpace H ⇑↑α ≤ LieSubmodule.restr I H | null | true |
CategoryTheory.Subfunctor.IsFinite.x._proof_1 | Mathlib.CategoryTheory.Subfunctor.Finite | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C] {F : CategoryTheory.Functor Cᵒᵖ (Type u_1)}
{G : CategoryTheory.Subfunctor F} [hG : G.IsFinite], ∃ x, Nonempty (G.IsGeneratedBy x) | null | false |
Matrix.IsStrictlyPositive.posDef | Mathlib.Analysis.Matrix.Order | ∀ {𝕜 : Type u_1} {n : Type u_2} [inst : RCLike 𝕜] [inst_1 : Fintype n] [inst_2 : DecidableEq n] {x : Matrix n n 𝕜},
IsStrictlyPositive x → x.PosDef | **Alias** of the forward direction of `Matrix.isStrictlyPositive_iff_posDef`. | true |
CategoryTheory.GrothendieckTopology.OneHypercover.recOn | Mathlib.CategoryTheory.Sites.Hypercover.One | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{J : CategoryTheory.GrothendieckTopology C} →
{S : C} →
{motive : J.OneHypercover S → Sort u_1} →
(t : J.OneHypercover S) →
((toPreOneHypercover : CategoryTheory.PreOneHypercover S) →
(mem₀ : toPreOneHyp... | null | false |
_private.Mathlib.MeasureTheory.Covering.Vitali.0.Vitali.exists_disjoint_covering_ae'._proof_1_1 | Mathlib.MeasureTheory.Covering.Vitali | (2 + 1).AtLeastTwo | null | false |
FundamentalGroupoidFunctor.prodToProdTop | Mathlib.AlgebraicTopology.FundamentalGroupoid.Product | (A : TopCat) →
(B : TopCat) →
CategoryTheory.Functor
(↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj A) ×
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj B))
↑(FundamentalGroupoid.fundamentalGroupoidFunctor.obj ↧(↑A × ↑B)) | The map taking the product of two fundamental groupoids to the fundamental groupoid of the product
of the two topological spaces. This is in fact an isomorphism (see `prodIso`).
| true |
BitVec.clzAuxRec._unsafe_rec | Init.Data.BitVec.Basic | {w : ℕ} → BitVec w → ℕ → BitVec w | null | false |
ProofWidgets.MarkdownDisplay.Props.mk._flat_ctor | ProofWidgets.Component.Basic | String → ProofWidgets.MarkdownDisplay.Props | null | false |
AlgebraicGeometry.geometrically_iff_of_commRing_of_isClosedUnderIsomorphisms | Mathlib.AlgebraicGeometry.Geometrically.Basic | ∀ {X : AlgebraicGeometry.Scheme} {P : CategoryTheory.ObjectProperty AlgebraicGeometry.Scheme} {R : Type u}
[inst : CommRing R] {f : X ⟶ AlgebraicGeometry.Spec ↧R} [P.IsClosedUnderIsomorphisms],
AlgebraicGeometry.geometrically P f ↔
∀ (K : Type u) [inst_2 : Field K] [inst_3 : Algebra R K],
P (CategoryTheor... | null | true |
QuotientAddGroup.addEquivPiModRangeNSMulAddMonoidHom._proof_7 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_2} (A : ι → Type u_1) [inst : (i : ι) → AddCommGroup (A i)] (n : ℕ)
(y : (i : ι) → A i ⧸ (nsmulAddMonoidHom n).range),
∃ a, { toFun := fun x x_1 => ↑(x x_1), map_zero' := ⋯, map_add' := ⋯ } a = y | null | false |
Fin._sizeOf_1._@.Mathlib.Util.CompileInductive.3310122970._hygCtx._hyg.231 | Mathlib.Util.CompileInductive | {n : ℕ} → Fin n → ℕ | null | false |
TensorProduct.addCommGroup._proof_5 | Mathlib.LinearAlgebra.TensorProduct.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M],
SMulCommClass R ℤ M | null | false |
Std.Sat.CNF.unsat_iff_not_sat | Std.Sat.CNF.Sat | ∀ {α : Type u_1} {f : Std.Sat.CNF α}, f.Unsat ↔ ∀ (a : α → Bool), ¬Std.Sat.CNF.Sat a f | null | true |
normEDSRec._proof_5 | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ (x : ℕ), x + 5 < 2 * (x + 3) | null | false |
_private.Lean.Meta.Sym.AlphaShareBuilder.0.Lean.Expr.updateLambdaS!.match_1 | Lean.Meta.Sym.AlphaShareBuilder | (motive : Lean.Expr → Sort u_1) →
(e : Lean.Expr) →
((n : Lean.Name) → (d b : Lean.Expr) → (bi : Lean.BinderInfo) → motive (Lean.Expr.lam n d b bi)) →
((x : Lean.Expr) → motive x) → motive e | null | false |
_private.Mathlib.Order.Defs.Unbundled.0.instIsTransPropAnd.match_1 | Mathlib.Order.Defs.Unbundled | ∀ (x x_1 : Prop) (motive : x ∧ x_1 → Prop) (x_2 : x ∧ x_1), (∀ (left : x) (b : x_1), motive ⋯) → motive x_2 | null | false |
Option.bind_id_eq_join | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {x : Option (Option α)}, x.bind id = x.join | null | true |
instLatticeSubtypeIsIdempotentElem._proof_10 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a b c : { a // IsIdempotentElem a }), a ≤ b → a ≤ c → a ≤ SemilatticeInf.inf b c | null | false |
Real.logb_zero_left_eq_zero | Mathlib.Analysis.SpecialFunctions.Log.Base | Real.logb 0 = 0 | null | true |
Lean.Meta.Grind.EMatchTheoremConstraint.guard.inj | Lean.Meta.Tactic.Grind.Extension | ∀ {e e_1 : Lean.Expr},
Lean.Meta.Grind.EMatchTheoremConstraint.guard e = Lean.Meta.Grind.EMatchTheoremConstraint.guard e_1 → e = e_1 | null | true |
AlgebraicGeometry.Scheme.smallEtaleTopology | Mathlib.AlgebraicGeometry.Sites.Etale | (X : AlgebraicGeometry.Scheme) → CategoryTheory.GrothendieckTopology X.Etale | The small étale site of a scheme is the Grothendieck topology on the
category of schemes étale over `X` induced from the étale topology on `Scheme.{u}`. | true |
LinearMap.IsSymmetric.id._simp_1 | Mathlib.Analysis.InnerProductSpace.Symmetric | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : SeminormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
LinearMap.id.IsSymmetric = True | null | false |
Int.add_le_of_le_neg_add | Init.Data.Int.Order | ∀ {a b c : ℤ}, b ≤ -a + c → a + b ≤ c | null | true |
_private.Mathlib.Algebra.FreeMonoid.FreeSemigroup.0.FreeSemigroup.range_toFreeMonoid._proof_1_1 | Mathlib.Algebra.FreeMonoid.FreeSemigroup | ∀ {α : Type u_1} (x : FreeMonoid α), x ∈ Set.range ⇑FreeSemigroup.toFreeMonoid ↔ x ∈ {1}ᶜ | null | false |
SimplicialObject.opEquivalence._proof_2 | Mathlib.AlgebraicTopology.SimplicialObject.Op | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] (X : CategoryTheory.SimplicialObject C),
CategoryTheory.CategoryStruct.comp
(SimplicialObject.opFunctor.map (SimplicialObject.opFunctorCompOpFunctorIso.symm.hom.app X))
(SimplicialObject.opFunctorCompOpFunctorIso.hom.app (SimplicialObject.opFu... | null | false |
CategoryTheory.Limits.limit.isLimitToOver | Mathlib.CategoryTheory.Limits.Over | {J : Type w} →
[inst : CategoryTheory.Category.{w', w} J] →
{C : Type u} →
[inst_1 : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor J C) →
[inst_2 : CategoryTheory.Limits.HasLimit F] →
CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.limit.toUnder F) | If `F` has a limit, then the cone `limit.toUnder F` with cone point `𝟙 (limit F)` is
also a limit cone. | true |
Lean.Language.SnapshotTree.foldSnaps.Control.proceed.noConfusion | Lean.Language.Lean.Util | {P : Sort u} →
{foldChildren foldChildren' : Bool} →
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren =
Lean.Language.SnapshotTree.foldSnaps.Control.proceed foldChildren' →
(foldChildren = foldChildren' → P) → P | null | false |
PSet.Subset | Mathlib.SetTheory.ZFC.PSet | PSet.{u_1} → PSet.{u_2} → Prop | A pre-set is a subset of another pre-set if every element of the first family is extensionally
equivalent to some element of the second family. | true |
mabs_div_le_max_div | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b c : G},
a ≤ b → b ≤ c → ∀ (d : G), |b / d|ₘ ≤ max (c / d) (d / a) | null | true |
RatFunc.CompletionAtInfty.instField._proof_27 | Mathlib.FieldTheory.RatFunc.Valuation | ∀ (F : Type u_1) [inst : Field F] [inst_1 : DecidableEq (RatFunc F)] (a b c : RatFunc.CompletionAtInfty F),
(a + b) * c = a * c + b * c | null | false |
Finsupp.weight_single_one_apply | Mathlib.Data.Finsupp.Weight | ∀ {σ : Type u_1} {R : Type u_3} [inst : Semiring R] [inst_1 : DecidableEq σ] (s : σ) (f : σ →₀ R),
(Finsupp.weight (Pi.single s 1)) f = f s | null | true |
forall_and_left | Mathlib.Basic.Logic.Basic | ∀ {α : Sort u_1} [Nonempty α] (q : Prop) (p : α → Prop), (∀ (x : α), q ∧ p x) ↔ q ∧ ∀ (x : α), p x | null | true |
DFinsupp.filter_eq' | Mathlib.Data.DFinsupp.Defs | ∀ {ι : Type u} {β : ι → Type v} [inst : (i : ι) → Zero (β i)] [inst_1 : DecidableEq ι] (f : Π₀ (i : ι), β i) (i : ι),
DFinsupp.filter (fun x => x = i) f = fun₀ | i => f i | null | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.termρᵣ | Mathlib.CategoryTheory.Monoidal.Action.Basic | Lean.ParserDescr | Notation for `actionUnitIso`, the structural isomorphism `- ⊙ᵣ 𝟙_ C ≅ -`. | true |
_private.Init.Data.String.Lemmas.FindPos.0.String.Slice.le_posLE_iff._simp_1_2 | Init.Data.String.Lemmas.FindPos | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
Subalgebra.perfectClosure._proof_2 | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ (R : Type u_2) (A : Type u_1) [inst : CommSemiring R] [inst_1 : CommSemiring A] [inst_2 : Algebra R A] (p : ℕ)
[ExpChar A p] {a b : A},
a ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} →
b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} → a + b ∈ {x | ∃ n, x ^ p ^ n ∈ (algebraMap R A).rangeS} | null | false |
instWellFoundedLTOrderDualOfWellFoundedGT | Mathlib.Order.RelClasses | ∀ (α : Type u_1) [inst : LT α] [h : WellFoundedGT α], WellFoundedLT αᵒᵈ | null | true |
Std.IteratorAccess.ctorIdx | Init.Data.Iterators.Consumers.Monadic.Access | {α : Type w} → {m : Type w → Type w'} → {β : Type w} → {inst : Std.Iterator α m β} → Std.IteratorAccess α m → ℕ | null | false |
_private.Mathlib.LinearAlgebra.Lagrange.0.Lagrange.basisDivisor_inj._simp_1_6 | Mathlib.LinearAlgebra.Lagrange | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | null | false |
definition._proof_3._@.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital.144533954._hygCtx._hyg.8 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : MetricSpace R]
[inst_2 : NonUnitalRing A] [inst_3 : Module R A] (f : R → R) (a : A),
p a ∧ ContinuousOn f (quasispectrum R a) ∧ f 0 = 0 → f 0 = 0 | null | false |
ContinuousMap.linearIsometryBoundedOfCompact_apply_apply | Mathlib.Topology.ContinuousMap.Compact | ∀ {α : Type u_1} {E : Type u_3} [inst : TopologicalSpace α] [inst_1 : CompactSpace α]
[inst_2 : SeminormedAddCommGroup E] {𝕜 : Type u_4} [inst_3 : NormedRing 𝕜] [inst_4 : Module 𝕜 E]
[inst_5 : IsBoundedSMul 𝕜 E] (f : C(α, E)) (a : α), ((ContinuousMap.linearIsometryBoundedOfCompact α E 𝕜) f) a = f a | null | true |
LinearMap.mkContinuous_norm_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} (f : E →ₛₗ[σ₁₂] F) {C : ℝ},
... | If a continuous linear map is constructed from a linear map via the constructor `mkContinuous`,
then its norm is bounded by the bound given to the constructor if it is nonnegative. | true |
Lean.TheoremVal.mk._flat_ctor | Lean.Declaration | Lean.Name → List Lean.Name → Lean.Expr → Lean.Expr → List Lean.Name → Lean.TheoremVal | null | false |
SuccOrder.prelimitRecOn._proof_2 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} [inst : PartialOrder α] [inst_1 : SuccOrder α] (a : α),
¬Order.IsSuccPrelimit a → ∃ b, ¬IsMax b ∧ Order.succ b = a | null | false |
AlternativeMonad.map._inherited_default | Batteries.Control.AlternativeMonad | {m : Type u_1 → Type u_2} →
({α : Type u_1} → α → m α) → ({α β : Type u_1} → m α → (α → m β) → m β) → {α β : Type u_1} → (α → β) → m α → m β | null | false |
Ideal.Filtration.Stable.exists_pow_smul_eq | Mathlib.RingTheory.Filtration | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {I : Ideal R}
{F : I.Filtration M}, F.Stable → ∃ n₀, ∀ (k : ℕ), F.N (n₀ + k) = I ^ k • F.N n₀ | null | true |
Lean.Meta.DiscrTree.casesOn | Lean.Meta.DiscrTree.Types | {α : Type} →
{motive : Lean.Meta.DiscrTree α → Sort u} →
(t : Lean.Meta.DiscrTree α) →
((root : Lean.PersistentHashMap Lean.Meta.DiscrTree.Key (Lean.Meta.DiscrTree.Trie α)) → motive { root := root }) →
motive t | null | false |
MeasureTheory.Measure.measure_support_eq_zero_iff._auto_1 | Mathlib.MeasureTheory.Measure.Filter | Lean.Syntax | null | false |
_private.Mathlib.MeasureTheory.Measure.Haar.Basic.0.MeasureTheory.Measure.haar.chaar_sup_le._simp_1_2 | Mathlib.MeasureTheory.Measure.Haar.Basic | ∀ {α : Type u_1} [inst : Preorder α] {b x : α}, (x ∈ Set.Ici b) = (b ≤ x) | null | false |
_private.Mathlib.NumberTheory.Primorial.0.primorial_add._proof_1_3 | Mathlib.NumberTheory.Primorial | ∀ (m n : ℕ), m + 1 ≤ m + n + 1 | null | false |
Lean.Grind.Config.splitImp._default | Init.Grind.Config | Bool | null | false |
Complex.mul_cpow_ofReal_nonneg | Mathlib.Analysis.SpecialFunctions.Pow.Complex | ∀ {a b : ℝ}, 0 ≤ a → 0 ≤ b → ∀ (r : ℂ), (↑a * ↑b) ^ r = ↑a ^ r * ↑b ^ r | null | true |
CategoryTheory.ProjectiveResolution.complex_d_comp_π_f_zero | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] {Z : C} (P : CategoryTheory.ProjectiveResolution Z),
CategoryTheory.CategoryStruct.comp (P.complex.d 1 0) (P.π.f 0) = 0 | null | true |
Equiv.normedCommGroup.eq_1 | Mathlib.Analysis.Normed.Module.TransferInstance | ∀ {α : Type u_1} {β : Type u_2} [inst : NormedCommGroup β] (e : α ≃ β),
e.normedCommGroup =
{ toNorm := (NormedCommGroup.induced α β e.mulEquiv ⋯).toNorm,
toCommGroup := (NormedCommGroup.induced α β e.mulEquiv ⋯).toCommGroup, toPseudoMetricSpace := e.pseudometricSpace,
eq_of_dist_eq_zero := ⋯, dist_eq... | null | true |
Std.DTreeMap.Internal.Impl.containsThenInsert_fst_eq_containsₘ | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
(t : Std.DTreeMap.Internal.Impl α β) (htb : t.Balanced),
t.Ordered → ∀ (a : α) (b : β a), (Std.DTreeMap.Internal.Impl.containsThenInsert a b t htb).1 = t.containsₘ a | null | true |
Lean.Compiler.LCNF.MonadFVarSubst | Lean.Compiler.LCNF.CompilerM | (Type → Type) → outParam Lean.Compiler.LCNF.Purity → outParam Bool → Type | Interface for monads that have a free substitutions.
| true |
MeasureTheory.Measure.quasiMeasurePreserving_smul | Mathlib.MeasureTheory.Measure.Lebesgue.EqHaar | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : MeasurableSpace E] [BorelSpace E]
[FiniteDimensional ℝ E] (μ : MeasureTheory.Measure E) [μ.IsAddHaarMeasure] {r : ℝ},
r ≠ 0 → MeasureTheory.QuasiMeasurePreserving (fun x => r • x) μ μ | null | true |
Metric.closedBall_eq_sphere_of_nonpos | Mathlib.Topology.MetricSpace.Pseudo.Defs | ∀ {α : Type u} [inst : PseudoMetricSpace α] {x : α} {ε : ℝ}, ε ≤ 0 → Metric.closedBall x ε = Metric.sphere x ε | Closed balls and spheres coincide when the radius is non-positive | true |
Rack.PreEnvelGroupRel'.symm | Mathlib.Algebra.Quandle | {R : Type u} →
[inst : Rack R] → {a b : Rack.PreEnvelGroup R} → Rack.PreEnvelGroupRel' R a b → Rack.PreEnvelGroupRel' R b a | null | true |
Lean.ErrorExplanation.declLoc? | Lean.ErrorExplanation | Lean.ErrorExplanation → Option Lean.DeclarationLocation | null | true |
Module.rankAtStalk_tensorProduct_of_isScalarTower | Mathlib.RingTheory.Spectrum.Prime.FreeLocus | ∀ {R : Type uR} {M : Type uM} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] [Module.Flat R M]
[Module.Finite R M] {S : Type u_1} [inst_5 : CommRing S] [inst_6 : Algebra R S] (N : Type u_2)
[inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : Module S N] [inst_10 : IsScalarTower R S N]
[... | null | true |
WithTop.insertTop | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → Finset α ↪o Finset (WithTop α) | Given a finset on `α`, lift it to being a finset on `WithTop α`
using `WithTop.some` and then insert `⊤`. | true |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiCountable.pseudoEMetricSpace._simp_8 | Mathlib.Topology.MetricSpace.PiNat | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) | null | false |
SemiNormedGrp.explicitCokernelDesc._proof_1 | Mathlib.Analysis.Normed.Group.SemiNormedGrp.Kernels | ∀ {X Y Z : SemiNormedGrp} {f : X ⟶ Y} {g : Y ⟶ Z},
CategoryTheory.CategoryStruct.comp f g = 0 →
CategoryTheory.CategoryStruct.comp f g = CategoryTheory.CategoryStruct.comp 0 g | null | false |
GroupExtension.Splitting.instFunLike | Mathlib.GroupTheory.GroupExtension.Defs | {N : Type u_1} →
{E : Type u_2} →
{G : Type u_3} →
[inst : Group N] → [inst_1 : Group E] → [inst_2 : Group G] → (S : GroupExtension N E G) → FunLike S.Splitting G E | null | true |
SimpleGraph.cliqueFinset.congr_simp | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} (G G_1 : SimpleGraph α),
G = G_1 →
∀ [inst : Fintype α] [inst_1 : DecidableEq α] {inst_2 : DecidableRel G.Adj} [inst_3 : DecidableRel G_1.Adj]
(n n_1 : ℕ), n = n_1 → G.cliqueFinset n = G_1.cliqueFinset n_1 | null | true |
LocallyConstant.instInhabited._proof_1 | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : Inhabited Y],
IsLocallyConstant (Function.const X default) | null | false |
Batteries.Random.MersenneTwister.State.noConfusion | Batteries.Data.Random.MersenneTwister | {P : Sort u} →
{cfg : Batteries.Random.MersenneTwister.Config} →
{t : Batteries.Random.MersenneTwister.State cfg} →
{cfg' : Batteries.Random.MersenneTwister.Config} →
{t' : Batteries.Random.MersenneTwister.State cfg'} →
cfg = cfg' → t ≍ t' → Batteries.Random.MersenneTwister.State.noConfusi... | null | false |
MonoidAlgebra.liftGroupLikeBialgHom._proof_2 | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A]
(x y : GroupLike R A), ↑(x * y) = ↑x * ↑y | null | false |
String.mk | Init.Data.String.Bootstrap | List Char → String | null | true |
Option.decidableForallMem._proof_3 | Init.Data.Option.Instances | ∀ {α : Type u_1} {p : α → Prop} (a : α), ¬p a → ¬∀ a_1 ∈ some a, p a_1 | null | false |
_private.Init.Data.SInt.Bitwise.0.Int16.shiftRight_and._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int16}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.removeUnusedArguments? | Lean.Meta.SynthInstance | Lean.MetavarContext → Lean.Expr → Lean.MetaM (Option (Lean.Expr × Lean.Expr)) | If the type of the metavariable `mvar` has unused argument, return a pair `(α, transformer)`
where `α` is a new type without the unused arguments and the `transformer` is a function for converting a
solution with type `α` into a value that can be assigned to `mvar`.
Example: suppose `mvar` has type `(a : A) → (b : B a)... | true |
_private.Lean.Elab.Match.0.Lean.Elab.Term.withElaboratedLHS | Lean.Elab.Match | {α : Type} →
Array Lean.Elab.Term.PatternVarDecl →
Array Lean.Syntax →
Lean.Syntax →
ℕ →
Lean.Expr →
(Lean.Meta.Match.AltLHS → Lean.Expr → Lean.Elab.TermElabM α) →
ExceptT Lean.Elab.Term.PatternElabException Lean.Elab.TermElabM α | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.