name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Ordnode.mem.decidable | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [inst_1 : DecidableLE α] → (x : α) → (t : Ordnode α) → Decidable (x ∈ t) | null | true |
Complex.one_add_cpow_hasFPowerSeriesAt_zero | Mathlib.Analysis.Analytic.Binomial | ∀ {a : ℂ}, HasFPowerSeriesAt (fun x => (1 + x) ^ a) (binomialSeries ℂ a) 0 | null | true |
OrderHom.curry._proof_4 | Mathlib.Order.Hom.Basic | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
(f : α × β →o γ) (x x_1 : α), x ≤ x_1 → ∀ (x_2 : β), f (x, x_2) ≤ f (x_1, x_2) | null | false |
_private.Lean.Meta.Tactic.Grind.Types.0.Lean.Meta.Grind.Solvers.mergeTerms.go.match_1.eq_1 | Lean.Meta.Tactic.Grind.Types | ∀ (motive : Lean.Meta.Grind.SolverTerms × Lean.Meta.Grind.PendingSolverPropagationsData✝ → Sort u_1)
(s : Lean.Meta.Grind.SolverTerms) (p : Lean.Meta.Grind.PendingSolverPropagationsData✝)
(h_1 : (s : Lean.Meta.Grind.SolverTerms) → (p : Lean.Meta.Grind.PendingSolverPropagationsData✝) → motive (s, p)),
(match (s, p... | null | true |
CircleDeg1Lift.instLattice._proof_4 | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ (f : CircleDeg1Lift) (x : ℝ), f x ≤ f x | null | false |
Lean.Lsp.DiagnosticWith.relatedInformation?._default | Lean.Data.Lsp.Diagnostics | {α : Type} → Option (Array Lean.Lsp.DiagnosticRelatedInformation) | null | false |
Subgroup.closure_pi | Mathlib.Algebra.Group.Subgroup.Finite | ∀ {η : Type u_3} {f : η → Type u_4} [inst : (i : η) → Group (f i)] [Finite η] {s : (i : η) → Set (f i)},
(∀ (i : η), 1 ∈ s i) →
Subgroup.closure (Set.univ.pi fun i => s i) = Subgroup.pi Set.univ fun i => Subgroup.closure (s i) | null | true |
ContinuousAlternatingMap.instNormedSpace | Mathlib.Analysis.Normed.Module.Alternating.Basic | {𝕜 : Type u} →
{E : Type wE} →
{F : Type wF} →
{ι : Type v} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : SeminormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
... | null | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_impl_11 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → NonScalar → Lean.PHashMap α (Task Dynamic) | null | true |
WithBot.bot_lt_coe | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LT α] (a : α), ⊥ < ↑a | null | true |
MeasureTheory.MemLp.toLp | Mathlib.MeasureTheory.Function.LpSpace.Basic | {α : Type u_1} →
{E : Type u_4} →
{m : MeasurableSpace α} →
{p : ENNReal} →
{μ : MeasureTheory.Measure α} →
[inst : NormedAddCommGroup E] → (f : α → E) → MeasureTheory.MemLp f p μ → ↥(MeasureTheory.Lp E p μ) | make an element of Lp from a function verifying `MemLp` | true |
Lean.Syntax.SepArray.casesOn | Init.Prelude | {sep : String} →
{motive : Lean.Syntax.SepArray sep → Sort u} →
(t : Lean.Syntax.SepArray sep) →
((elemsAndSeps : Array Lean.Syntax) → motive { elemsAndSeps := elemsAndSeps }) → motive t | null | false |
Lean.Lsp.DiagnosticRelatedInformation.mk.noConfusion | Lean.Data.Lsp.Diagnostics | {P : Sort u} →
{location : Lean.Lsp.Location} →
{message : String} →
{location' : Lean.Lsp.Location} →
{message' : String} →
{ location := location, message := message } = { location := location', message := message' } →
(location = location' → message = message' → P) → P | null | false |
instInhabitedBool.default | Init.Prelude | Bool | null | true |
ProofWidgets.MakeEditLinkProps.recOn | ProofWidgets.Component.MakeEditLink | {motive : ProofWidgets.MakeEditLinkProps → Sort u} →
(t : ProofWidgets.MakeEditLinkProps) →
((edit : Lean.Lsp.TextDocumentEdit) →
(newSelection? : Option Lean.Lsp.Range) →
(title? : Option String) → motive { edit := edit, newSelection? := newSelection?, title? := title? }) →
motive t | null | false |
Std.ExtDHashMap.filter_eq_self_iff | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : α → Type v} {m : Std.ExtDHashMap α β} [inst : LawfulBEq α]
{f : (a : α) → β a → Bool}, Std.ExtDHashMap.filter f m = m ↔ ∀ (k : α) (h : k ∈ m), f k (m.get k h) = true | null | true |
_private.Mathlib.LinearAlgebra.Matrix.Notation.0.Matrix.delabMatrixNotation._sparseCasesOn_1 | Mathlib.LinearAlgebra.Matrix.Notation | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.ShortComplex.zero_assoc | Mathlib.Algebra.Homology.ShortComplex.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(self : CategoryTheory.ShortComplex C) {Z : C} (h : self.X₃ ⟶ Z),
CategoryTheory.CategoryStruct.comp self.f (CategoryTheory.CategoryStruct.comp self.g h) =
CategoryTheory.CategoryStruct.comp 0 h | the composition of the two given morphisms is zero | true |
Function.Injective.extend_injOn | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : α → γ} {j : β → γ},
Function.Injective f → Function.Injective g → Set.InjOn (Function.extend f g j) (Set.range f) | If `f` and `g` are injective, then `extend f g j` is injective on the range of `f`. | true |
WeierstrassCurve.integralModel | Mathlib.AlgebraicGeometry.EllipticCurve.Reduction | (R : Type u_1) →
[inst : CommRing R] →
{K : Type u_2} →
[inst_1 : Field K] →
[inst_2 : Algebra R K] → (W : WeierstrassCurve K) → [hW : WeierstrassCurve.IsIntegral R W] → WeierstrassCurve R | An integral model of an integral Weierstrass curve. | true |
_private.Mathlib.MeasureTheory.SetSemiring.0.MeasureTheory.IsSetSemiring.empty_notMem_disjointOfDiffUnion._simp_1_4 | Mathlib.MeasureTheory.SetSemiring | (¬True) = False | null | false |
_private.Std.Time.Date.Unit.Weekday.0.Std.Time.Weekday.toOrdinal.eq_5 | Std.Time.Date.Unit.Weekday | Std.Time.Weekday.friday.toOrdinal = 5 | null | true |
Mathlib.Tactic.ClickSuggestions.RwInfo.casesOn | Mathlib.Tactic.ClickSuggestions.Rewrite | {motive : Mathlib.Tactic.ClickSuggestions.RwInfo → Sort u} →
(t : Mathlib.Tactic.ClickSuggestions.RwInfo) →
((rootExpr subExpr : Lean.Expr) →
(rflTarget? : Option Lean.Expr) →
(pos : Lean.SubExpr.Pos) →
(rwKind : Mathlib.Tactic.ClickSuggestions.RwKind) →
motive
... | null | false |
RBTree.RBNode.IsCut.mk | BatteriesRecycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering},
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut x = Ordering.lt → cut y = Ordering.lt) →
(∀ {x y : α} [Std.TransCmp cmp], cmp x y ≠ Ordering.gt → cut y = Ordering.gt → cut x = Ordering.gt) →
RBTree.RBNode.IsCut cmp cut | null | true |
ArithmeticFunction.ppow_one | Mathlib.NumberTheory.ArithmeticFunction.Zeta | ∀ {R : Type u_1} [inst : Semiring R] {f : ArithmeticFunction R}, f.ppow 1 = f | null | true |
Std.DHashMap.Const.get?_inter_of_not_mem_left | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m₁ m₂ : Std.DHashMap α fun x => β} [EquivBEq α]
[LawfulHashable α] {k : α}, k ∉ m₁ → Std.DHashMap.Const.get? (m₁.inter m₂) k = none | null | true |
contMDiffWithinAt_pi_space | Mathlib.Geometry.Manifold.ContMDiff.Constructions | ∀ {𝕜 : 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] {s : Set M} {x : M} {n : WithTop ℕ∞} {ι... | null | true |
Equiv.semigroup | Mathlib.Algebra.Group.TransferInstance | {α : Type u_2} → {β : Type u_3} → α ≃ β → [Semigroup β] → Semigroup α | Transfer `Semigroup` across an `Equiv` | true |
Quaternion.mul_coe_eq_smul | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (r : R) (a : Quaternion R), a * ↑r = r • a | null | true |
Int.fib_dvd | Mathlib.Data.Int.Fib.Basic | ∀ (m n : ℤ), m ∣ n → Int.fib m ∣ Int.fib n | null | true |
List.mapM'.eq_def | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_1} [inst : Monad m] (f : α → m β) (x : List α),
List.mapM' f x =
match x with
| [] => pure []
| a :: l => do
let __do_lift ← f a
let __do_lift_1 ← List.mapM' f l
pure (__do_lift :: __do_lift_1) | null | true |
Batteries.Tactic.DeclCache.casesOn | 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 |
CategoryTheory.MonoidalCategory.MonoidalRightAction.oppositeRightAction_actionUnitIso | 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]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalRightAction C D] (x : Dᵒᵖ),
CategoryTheory.MonoidalCategory.MonoidalRightActionStruct.actionU... | null | true |
Bool.linearOrder._proof_9 | Mathlib.Data.Bool.Basic | ∀ (a b : Bool), compare a b = compareOfLessAndEq a b | null | false |
ZMod.inv | Mathlib.Data.ZMod.Basic | (n : ℕ) → ZMod n → ZMod n | The inversion on `ZMod n`.
It is setup in such a way that `a * a⁻¹` is equal to `gcd a.val n`.
In particular, if `a` is coprime to `n`, and hence a unit, `a * a⁻¹ = 1`. | true |
Aesop.instBEqPhaseName.beq | Aesop.Rule.Name | Aesop.PhaseName → Aesop.PhaseName → Bool | null | true |
AbsConvexOpenSets.coe_isOpen | Mathlib.Analysis.LocallyConvex.AbsConvexOpen | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : TopologicalSpace E] [inst_1 : AddCommMonoid E] [inst_2 : SeminormedRing 𝕜]
[inst_3 : SMul 𝕜 E] [inst_4 : PartialOrder 𝕜] (s : AbsConvexOpenSets 𝕜 E), IsOpen ↑s | null | true |
CategoryTheory.Pretriangulated.instSplitEpiCategory | Mathlib.CategoryTheory.Triangulated.Pretriangulated | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroObject C]
[inst_2 : CategoryTheory.HasShift C ℤ] [inst_3 : CategoryTheory.Preadditive C]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [hC : CategoryTheory.Pretriangulated C],
CategoryTheory.SplitEpi... | null | true |
CategoryTheory.SimplicialObject.Truncated._aux_Mathlib_AlgebraicTopology_SimplicialObject_Basic___macroRules_CategoryTheory_SimplicialObject_Truncated_mkNotation_1 | Mathlib.AlgebraicTopology.SimplicialObject.Basic | Lean.Macro | null | false |
_private.Mathlib.Order.Interval.Set.Disjoint.0.Set.Ioo_disjoint_Ioo._simp_1_2 | Mathlib.Order.Interval.Set.Disjoint | ∀ {α : Type u_1} [inst : Preorder α] {a b : α} [DenselyOrdered α], (Set.Ioo a b = ∅) = ¬a < b | null | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.snd_of_toSubgraph_adj._proof_1_7 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u v v' : V} {p : G.Walk u v} (i : ℕ),
(p.getVert i = u ∧ p.getVert (i + 1) = v' ∨ p.getVert i = v' ∧ p.getVert (i + 1) = u) ∧ i < p.length →
i + 1 ≤ p.length | null | false |
TensorProduct.leftModule | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
{R'' : Type u_5} →
[inst : CommSemiring R] →
[inst_1 : Semiring R''] →
{M : Type u_7} →
{N : Type u_8} →
[inst_2 : AddCommMonoid M] →
[inst_3 : AddCommMonoid N] →
[inst_4 : Module R'' M] →
[inst_5 : Module R M] →
... | null | true |
_private.Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots.0.IsPrimitiveRoot.card_nthRoots._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.PrimitiveRoots | ∀ {α : Type u_1} {s : Multiset α}, (s.card = 0) = (s = 0) | null | false |
Lean.Meta.Grind.Arith.Cutsat.SymbolicBound.rec | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | {motive : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound → Sort u} →
((val : Lean.Expr) → (ival? : Option ℤ) → motive { val := val, ival? := ival? }) →
(t : Lean.Meta.Grind.Arith.Cutsat.SymbolicBound) → motive t | null | false |
_private.Init.Data.ByteArray.Lemmas.0.ByteArray.append_right_inj._simp_1_1 | Init.Data.ByteArray.Lemmas | ∀ {x y : ByteArray}, (x = y) = (x.data = y.data) | null | false |
QuotientGroup.comapMk'OrderIso._proof_2 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {G : Type u_1} [inst : Group G] (N : Subgroup G) [hn : N.Normal] (x : { H // N ≤ H }),
N ≤ Subgroup.comap (QuotientGroup.mk' N) (Subgroup.map (QuotientGroup.mk' N) ↑x) | null | false |
Std.TreeSet.isNone_max?_eq_isEmpty | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp], t.max?.isNone = t.isEmpty | null | true |
Std.TreeMap.Raw.size_insert | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β}, (t.insert k v).size = if t.contains k = true then t.size else t.size + 1 | null | true |
Lean.reservedMacroScope | Init.Prelude | ℕ | Macro scope used internally. It is not available for our frontend. | true |
_private.Mathlib.Order.ConditionallyCompleteLattice.Indexed.0.cbiInf_of_not_bddBelow.match_1_1 | Mathlib.Order.ConditionallyCompleteLattice.Indexed | ∀ {α : Type u_1} {ι : Sort u_2} {p : ι → Prop} {f : (i : ι) → p i → α} (x : α)
(motive : (x ∈ Set.range fun i => f ↑i ⋯) → Prop) (x_1 : x ∈ Set.range fun i => f ↑i ⋯),
(∀ (x_2 : Subtype p) (hx : (fun i => f ↑i ⋯) x_2 = x), motive ⋯) → motive x_1 | null | false |
cfcₙ_comp_smul._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
Std.TreeMap.getKey!_union | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α] {k : α}, (t₁ ∪ t₂).getKey! k = t₂.getKeyD k (t₁.getKey! k) | null | true |
Std.ExtHashSet.get?_eq_some_of_contains | Std.Data.ExtHashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashSet α} [inst : LawfulBEq α] {k : α},
m.contains k = true → m.get? k = some k | null | true |
RingCon.instZeroQuotient | Mathlib.RingTheory.Congruence.Defs | {R : Type u_1} → [inst : AddZeroClass R] → [inst_1 : Mul R] → (c : RingCon R) → Zero c.Quotient | null | true |
LinearMap.ker_eq_top._simp_1 | Mathlib.Algebra.Module.Submodule.Ker | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂}, (f.ker = ⊤) = (f = 0) | null | false |
RegularWreathProduct.mk.injEq | Mathlib.GroupTheory.RegularWreathProduct | ∀ {D : Type u_1} {Q : Type u_2} (left : Q → D) (right : Q) (left_1 : Q → D) (right_1 : Q),
({ left := left, right := right } = { left := left_1, right := right_1 }) = (left = left_1 ∧ right = right_1) | null | true |
Field.Emb.Cardinal.leastExt.eq_1 | Mathlib.FieldTheory.CardinalEmb | ∀ (F : Type u) (E : Type v) [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E],
Field.Emb.Cardinal.leastExt F E =
⋯.fix fun i ih =>
let s := Set.range fun j => (Field.Emb.Cardinal.wellOrderedBasis F E) (ih ↑j ... | null | true |
ContinuousAlgHom.coe_mk' | 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]
(f : A →ₐ[R] B) (h : Continuous (↑↑f.toRingHom).toFun), ⇑{ toAlgHom := f, cont := h } = ⇑f | null | true |
OrderDual.ofDual_inj | Mathlib.Order.OrderDual | ∀ {α : Type u_1} {a b : αᵒᵈ}, OrderDual.ofDual a = OrderDual.ofDual b ↔ a = b | null | true |
Lean.DefinitionVal._sizeOf_inst | Lean.Declaration | SizeOf Lean.DefinitionVal | null | false |
ProbabilityTheory.variance_id_gaussianReal | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal}, ProbabilityTheory.variance id (ProbabilityTheory.gaussianReal μ v) = ↑v | The variance of a real Gaussian distribution `gaussianReal μ v` is
its variance parameter `v`. | true |
Turing.PartrecToTM2.trStmts₁_supports' | Mathlib.Computability.TuringMachine.ToPartrec | ∀ {S : Finset Turing.PartrecToTM2.Λ'} {q : Turing.PartrecToTM2.Λ'} {K : Finset Turing.PartrecToTM2.Λ'},
Turing.PartrecToTM2.Λ'.Supports S q →
Turing.PartrecToTM2.trStmts₁ q ∪ K ⊆ S →
(K ⊆ S → Turing.PartrecToTM2.Supports K S) → Turing.PartrecToTM2.Supports (Turing.PartrecToTM2.trStmts₁ q ∪ K) S | null | true |
IterateMulAct.mk._flat_ctor | Mathlib.GroupTheory.GroupAction.IterateAct | {α : Type u_1} → {f : α → α} → ℕ → IterateMulAct f | null | false |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.visitLambdaLet.go._sparseCasesOn_1 | Lean.Meta.LetToHave | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.lam binderName binderType body binderInfo)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) → (nondep : Bool)... | null | false |
Std.Time.Year.instSubOffset | Std.Time.Date.Unit.Year | Sub Std.Time.Year.Offset | null | true |
Lean.Elab.MonadAutoImplicits.recOn | Lean.Elab.InfoTree.Types | {m : Type → Type} →
{motive : Lean.Elab.MonadAutoImplicits m → Sort u} →
(t : Lean.Elab.MonadAutoImplicits m) →
((getAutoImplicits : m (Array Lean.Expr)) → motive { getAutoImplicits := getAutoImplicits }) → motive t | null | false |
Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof.symm | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.Meta.Grind.Arith.Linear.RingEqCnstr → Lean.Meta.Grind.Arith.Linear.RingEqCnstrProof | null | true |
_private.Init.Data.Range.Polymorphic.SInt.0.ISize.instUpwardEnumerable._proof_3 | Init.Data.Range.Polymorphic.SInt | ∀ (n : ℕ) (i : ISize), i.toInt + ↑n ≤ ISize.maxValueSealed✝.toInt → i.toInt + ↑n ≤ ISize.maxValue.toInt | null | false |
AlgebraicGeometry.Scheme.instCategoryAffineEtale._proof_8 | Mathlib.AlgebraicGeometry.Sites.AffineEtale | ∀ (S : AlgebraicGeometry.Scheme),
autoParam
(∀ {X Y : S.AffineEtale} (f : X ⟶ Y), CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.id Y) = f)
CategoryTheory.Category.comp_id._autoParam | null | false |
RingHom.HasEqualizers.createsLimitsWalkingParallelPair | Mathlib.Algebra.Category.Ring.Under.Property | {Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop} →
(RingHom.RespectsIso fun {R S} [CommRing R] [CommRing S] => Q) →
(RingHom.HasEqualizers fun {R S} [CommRing R] [CommRing S] => Q) →
(R : CommRingCat) →
CategoryTheory.CreatesLimitsOfShape CategoryTheory.Limits.Wa... | If `Q` is stable under equalizers, the inclusion from the subcategory of `Under R` defined
by `Q` creates equalizers. | true |
Associated.mul_mul | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] {a₁ a₂ b₁ b₂ : M},
Associated a₁ b₁ → Associated a₂ b₂ → Associated (a₁ * a₂) (b₁ * b₂) | null | true |
Std.Async.Sleep.noConfusionType | Std.Async.Timer | Sort u → Std.Async.Sleep → Std.Async.Sleep → Sort u | null | false |
add_pow_eq_mul_pow_add_pow_div_char | Mathlib.Algebra.CharP.Lemmas | ∀ {R : Type u_1} [inst : CommSemiring R] (x y : R) (p n : ℕ) [hp : Fact (Nat.Prime p)] [CharP R p],
(x + y) ^ n = (x + y) ^ (n % p) * (x ^ p + y ^ p) ^ (n / p) | null | true |
Submodule.generators_card | Mathlib.Algebra.Module.SpanRank | ∀ {R : Type u_1} {M : Type u} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] (p : Submodule R M),
Cardinal.mk ↑p.generators = p.spanRank | null | true |
NNRat.cast_inj | Mathlib.Data.Rat.Cast.CharZero | ∀ {α : Type u_3} [inst : DivisionSemiring α] [CharZero α] {p q : ℚ≥0}, ↑p = ↑q ↔ p = q | null | true |
Ordinal.cof_eq_zero._simp_1 | Mathlib.SetTheory.Cardinal.Cofinality.Ordinal | ∀ {o : Ordinal.{u_1}}, (o.cof = 0) = (o = 0) | null | false |
List.isPrefixOfAux_toArray_succ'._proof_2 | Init.Data.List.ToArray | ∀ {α : Type u_1} (l₁ l₂ : List α),
l₁.length ≤ l₂.length → ∀ (i : ℕ), (List.drop (i + 1) l₁).toArray.size ≤ (List.drop (i + 1) l₂).toArray.size | null | false |
groupHomology.shortComplexH2_g | Mathlib.RepresentationTheory.Homological.GroupHomology.LowDegree | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G),
(groupHomology.shortComplexH2 A).g = groupHomology.d₂₁ A | null | true |
_private.Std.Data.String.ToNat.0.String.Slice.isNat_iff'._simp_1_24 | Std.Data.String.ToNat | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Aesop.Frontend.BuilderOption.rec | Aesop.Frontend.RuleExpr | {motive : Aesop.Frontend.BuilderOption → Sort u} →
((names : Array Lean.Name) → motive (Aesop.Frontend.BuilderOption.immediate names)) →
((imode : Aesop.IndexingMode) → motive (Aesop.Frontend.BuilderOption.index imode)) →
((stx : Lean.Term) → motive (Aesop.Frontend.BuilderOption.pattern stx)) →
((pa... | null | false |
_private.Mathlib.Algebra.Module.LocalizedModule.Submodule.0.IsLocalizedModule.toLocalizedQuotient'._simp_2 | Mathlib.Algebra.Module.LocalizedModule.Submodule | ∀ {R : Type u_1} {M : Type u_2} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (p : Submodule R M)
{x y : M}, (Submodule.Quotient.mk x = Submodule.Quotient.mk y) = (x - y ∈ p) | null | false |
Polynomial.Splits.of_degree_eq_two | Mathlib.Algebra.Polynomial.Splits | ∀ {R : Type u_1} [inst : Field R] {f : Polynomial R} {x : R}, f.degree = 2 → Polynomial.eval x f = 0 → f.Splits | null | true |
Height.AdmissibleAbsValues.mk._flat_ctor | Mathlib.NumberTheory.Height.Basic | {K : Type u_1} →
[inst : Field K] →
(archAbsVal : Multiset (AbsoluteValue K ℝ)) →
(nonarchAbsVal : Set (AbsoluteValue K ℝ)) →
(∀ v ∈ nonarchAbsVal, IsNonarchimedean ⇑v) →
(∀ {x : K}, x ≠ 0 → Function.HasFiniteMulSupport fun v => ↑v x) →
(∀ {x : K}, x ≠ 0 → (Multiset.map (fun x_... | null | false |
Plausible.GenError.ctorIdx | Plausible.Gen | Plausible.GenError → ℕ | null | false |
CancelCommMonoidWithZero.toIsLeftCancelMulZero | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} (self : CancelCommMonoidWithZero M₀), IsLeftCancelMulZero M₀ | null | true |
Std.TreeMap.Raw.WF.insertManyIfNewUnit | Std.Data.TreeMap.Raw.WF | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {ρ : Type u_1} [inst : ForIn Id ρ α] {l : ρ}
{t : Std.TreeMap.Raw α Unit cmp}, t.WF → (t.insertManyIfNewUnit l).WF | null | true |
antilipschitzWith_inv_iff | Mathlib.Analysis.Normed.Group.Uniform | ∀ {α : Type u_4} {E : Type u_5} [inst : SeminormedCommGroup E] [inst_1 : PseudoEMetricSpace α] {K : NNReal} {f : α → E},
AntilipschitzWith K f⁻¹ ↔ AntilipschitzWith K f | null | true |
Pi.single_mul_right | Mathlib.Algebra.GroupWithZero.Pi | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MulZeroClass (α i)] [inst_1 : DecidableEq ι] {i : ι}
{f : (i : ι) → α i} (a : α i), Pi.single i (f i * a) = f * Pi.single i a | null | true |
Lean.Elab.Tactic.Grind.Cache._sizeOf_1 | Lean.Elab.Tactic.Grind.Basic | Lean.Elab.Tactic.Grind.Cache → ℕ | null | false |
Fact.mk | Mathlib.Logic.Basic | ∀ {p : Prop}, p → Fact p | null | true |
_private.Lean.Meta.Sym.Arith.EvalNum.0.Lean.Meta.Sym.Arith.evalNatCore.match_1 | Lean.Meta.Sym.Arith.EvalNum | (motive : Id (Option ℕ) → Sort u_1) →
(x : Id (Option ℕ)) → ((n : ℕ) → motive (some n)) → ((x : Id (Option ℕ)) → motive x) → motive x | null | false |
Lean.Expr.mapForallBinderNames._f | Mathlib.Lean.Expr.Basic | (x : Lean.Expr) →
Lean.Expr.below (motive := fun x => (Lean.Name → Lean.Name) → Lean.Expr) x → (Lean.Name → Lean.Name) → Lean.Expr | null | false |
Set.chainHeight_coe_univ | Mathlib.Order.Height | ∀ {α : Type u_1} (s : Set α) (r : α → α → Prop), (Set.univ.chainHeight fun x1 x2 => r ↑x1 ↑x2) = s.chainHeight r | null | true |
Valuation.restrict_le_iff_le_embedding | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedCommGroupWithZero Γ₀] (v : Valuation R Γ₀)
{x : R} {g : (MonoidWithZeroHom.ofClass v).ValueGroup₀},
v.restrict x ≤ g ↔ v x ≤ MonoidWithZeroHom.ValueGroup₀.embedding g | null | true |
Batteries.BEqCmp.cmp_iff_beq | Batteries.Classes.Deprecated | ∀ {α : Type u_1} {inst : BEq α} {cmp : α → α → Ordering} [self : Batteries.BEqCmp cmp] {x y : α},
cmp x y = Ordering.eq ↔ (x == y) = true | `cmp x y = .eq` holds iff `x == y` is true. | true |
Lean.Lsp.FileChangeType.recOn | Lean.Data.Lsp.Workspace | {motive : Lean.Lsp.FileChangeType → Sort u} →
(t : Lean.Lsp.FileChangeType) →
motive Lean.Lsp.FileChangeType.Created →
motive Lean.Lsp.FileChangeType.Changed → motive Lean.Lsp.FileChangeType.Deleted → motive t | null | false |
NNRat.instMetricSpace._proof_24 | Mathlib.Topology.Instances.Rat | ∀ {x y : ℚ≥0}, dist x y = 0 → x = y | null | false |
CategoryTheory.Bicategory.Adj.Hom₂.ctorIdx | Mathlib.CategoryTheory.Bicategory.Adjunction.Adj | {B : Type u} →
{inst : CategoryTheory.Bicategory B} →
{a b : CategoryTheory.Bicategory.Adj B} → {α β : a ⟶ b} → CategoryTheory.Bicategory.Adj.Hom₂ α β → ℕ | null | false |
BitVec.getLsbD_succ_last | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} (x : BitVec (w + 1)), x.getLsbD w = decide (2 ^ w ≤ x.toNat) | null | true |
_private.Mathlib.ModelTheory.Encoding.0.FirstOrder.Language.BoundedFormula.listEncode.match_1.eq_2 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u_3} (motive : (x : ℕ) → L.BoundedFormula α x → Sort u_4) (x : ℕ)
(t₁ t₂ : L.Term (α ⊕ Fin x)) (h_1 : (n : ℕ) → motive n FirstOrder.Language.BoundedFormula.falsum)
(h_2 : (x : ℕ) → (t₁ t₂ : L.Term (α ⊕ Fin x)) → motive x (FirstOrder.Language.BoundedFormula.equal t₁ t₂))
(h_3 ... | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.