name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Server.Snapshots.Snapshot.mk.injEq | Lean.Server.Snapshots | ∀ (stx : Lean.Syntax) (mpState : Lean.Parser.ModuleParserState) (cmdState : Lean.Elab.Command.State)
(stx_1 : Lean.Syntax) (mpState_1 : Lean.Parser.ModuleParserState) (cmdState_1 : Lean.Elab.Command.State),
({ stx := stx, mpState := mpState, cmdState := cmdState } =
{ stx := stx_1, mpState := mpState_1, cmdSt... | null | true |
Lean.CodeAction.CommandCodeActionEntry.noConfusion | Lean.Server.CodeActions.Attr | {P : Sort u} →
{t t' : Lean.CodeAction.CommandCodeActionEntry} →
t = t' → Lean.CodeAction.CommandCodeActionEntry.noConfusionType P t t' | null | false |
CategoryTheory.CommRingObjCat.Hom._sizeOf_inst | Mathlib.CategoryTheory.Monoidal.Ring | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.CartesianMonoidalCategory C} →
{inst_2 : CategoryTheory.BraidedCategory C} →
(R₁ R₂ : CategoryTheory.CommRingObjCat C) → [SizeOf C] → SizeOf (R₁.Hom R₂) | null | false |
CategoryTheory.Subobject.Classifier.mk.inj | Mathlib.CategoryTheory.Subobject.Classifier.Defs | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {Ω₀ Ω : C} {truth : Ω₀ ⟶ Ω}
{mono_truth : autoParam (CategoryTheory.Mono truth) CategoryTheory.Subobject.Classifier.mono_truth._autoParam}
{χ₀ : (U : C) → U ⟶ Ω₀} {χ : {U X : C} → (m : U ⟶ X) → [CategoryTheory.Mono m] → X ⟶ Ω}
{isPullback :
∀ {U X : C} ... | null | true |
_private.Lean.Meta.Tactic.Grind.Intro.0.Lean.Meta.Grind.IntroResult.done.noConfusion | Lean.Meta.Tactic.Grind.Intro | {P : Sort u} →
{goal goal' : Lean.Meta.Grind.Goal} →
Lean.Meta.Grind.IntroResult.done✝ goal = Lean.Meta.Grind.IntroResult.done✝ goal' → (goal = goal' → P) → P | null | false |
HurwitzZeta.hurwitzZetaEven_apply_zero | Mathlib.NumberTheory.LSeries.HurwitzZetaEven | ∀ (a : UnitAddCircle), HurwitzZeta.hurwitzZetaEven a 0 = if a = 0 then -1 / 2 else 0 | null | true |
Lean.Elab.Command.instInhabitedPreElabHeaderResult | Lean.Elab.MutualInductive | Inhabited Lean.Elab.Command.PreElabHeaderResult | null | true |
ComplexShape.embeddingDown'Add._proof_1 | Mathlib.Algebra.Homology.Embedding.Basic | ∀ {A : Type u_1} [inst : AddCommSemigroup A] [inst_1 : IsRightCancelAdd A] (a b i₁ i₂ : A),
(ComplexShape.down' a).Rel i₁ i₂ ↔ (ComplexShape.down' a).Rel (i₁ + b) (i₂ + b) | null | false |
Std.Http.Internal.Mock.Client.casesOn | Std.Http.Transport | {motive : Std.Http.Internal.Mock.Client → Sort u} →
(t : Std.Http.Internal.Mock.Client) →
((shared : Std.Http.Internal.Mock.SharedState✝) → motive { shared := shared }) → motive t | null | false |
instTransIff | Init.Core | Trans Iff Iff Iff | null | true |
_private.Lean.Parser.Command.0.Lean.Parser.Tactic.open._regBuiltin.Lean.Parser.Tactic.open.docString_3 | Lean.Parser.Command | IO Unit | null | false |
_private.Mathlib.RingTheory.Smooth.NoetherianDescent.0.Algebra.Smooth.DescentAux.algebra₂._proof_4 | Mathlib.RingTheory.Smooth.NoetherianDescent | ∀ (R : Type u_2) [inst : CommRing R] {A : Type u_1} {B : Type u_3} [inst_1 : CommRing A] [inst_2 : Algebra R A]
[inst_3 : CommRing B] [inst_4 : Algebra A B] (D : Algebra.Smooth.DescentAux✝ A B)
(r : ↥(Algebra.Smooth.DescentAux.subalgebra✝ R D)) (x : B),
r • x = (Algebra.Smooth.DescentAux.algebra₂._aux_1✝ R D) r *... | null | false |
_private.Std.Http.Data.URI.Parser.0.Std.Http.URI.Parser.parseQuery._sparseCasesOn_1 | Std.Http.Data.URI.Parser | {α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.Limits.hasPullback_op_iff_hasPushout | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y Z : C} (f : X ⟶ Y) (g : X ⟶ Z),
CategoryTheory.Limits.HasPullback f.op g.op ↔ CategoryTheory.Limits.HasPushout f g | null | true |
Set.Icc.instOrderBotElemOfFactLe.eq_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} {a b : α} [inst : Preorder α] [inst_1 : Fact (a ≤ b)], Set.Icc.instOrderBotElemOfFactLe = ⋯.orderBot | null | true |
Real.sinc_apply | Mathlib.Analysis.SpecialFunctions.Trigonometric.Sinc | ∀ {x : ℝ}, Real.sinc x = if x = 0 then 1 else Real.sin x / x | null | true |
IsStrictlyPositive.isUnit_cfcSqrt | Mathlib.Analysis.SpecialFunctions.ContinuousFunctionalCalculus.Rpow.Basic | ∀ {A : Type u_1} [inst : PartialOrder A] [inst_1 : Ring A] [inst_2 : StarRing A] [inst_3 : TopologicalSpace A]
[inst_4 : StarOrderedRing A] [inst_5 : Algebra ℝ A] [inst_6 : ContinuousFunctionalCalculus ℝ A IsSelfAdjoint]
[inst_7 : NonnegSpectrumClass ℝ A] [IsSemitopologicalRing A] [T2Space A] (a : A),
autoParam (... | null | true |
Nucleus.instFrame._proof_4 | Mathlib.Order.Nucleus | ∀ {X : Type u_1} [inst : Order.Frame X] (a b : Nucleus X), Lattice.inf a b ≤ b | null | false |
iSup_symmDiff_iSup_le | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u} {ι : Sort w} [inst : Order.Coframe α] {f g : ι → α},
symmDiff (⨆ i, f i) (⨆ i, g i) ≤ ⨆ i, symmDiff (f i) (g i) | The symmetric difference of two `iSup`s is at most the `iSup` of the symmetric differences. | true |
_private.Mathlib.Algebra.GroupWithZero.Invertible.0.invertibleDiv._simp_1 | Mathlib.Algebra.GroupWithZero.Invertible | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b c : G), a * (b / c) = a * b / c | null | false |
Filter.le_map₂_iff | Mathlib.Order.Filter.NAry | ∀ {α : Type u_1} {β : Type u_3} {γ : Type u_5} {m : α → β → γ} {f : Filter α} {g : Filter β} {h : Filter γ},
h ≤ Filter.map₂ m f g ↔ ∀ ⦃s : Set α⦄, s ∈ f → ∀ ⦃t : Set β⦄, t ∈ g → Set.image2 m s t ∈ h | null | true |
Set.image_val_sUnion | Mathlib.Data.Set.Subset | ∀ {α : Type u_2} {A : Set α} {T : Set (Set ↑A)}, Subtype.val '' ⋃₀ T = ⋃₀ {x | ∃ B ∈ T, Subtype.val '' B = x} | null | true |
Numbering.prefixedEquiv._proof_4 | Mathlib.Combinatorics.KatonaCircle | ∀ {X : Type u_1} [inst : Fintype X] (s : Finset X), Fintype.card ↥s ≤ Fintype.card X | null | false |
Subgroup.transferTransversal | Mathlib.GroupTheory.Transfer | {G : Type u_1} → [inst : Group G] → (H : Subgroup G) → G → H.LeftTransversal | The transfer transversal. Contains elements of the form `g ^ k • g₀` for fixed choices
of representatives `g₀` of fixed choices of representatives `q₀` of `⟨g⟩`-orbits in `G ⧸ H`. | true |
AddAction.IsBlock.orbit_of_normal | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : AddGroup G] {X : Type u_2} [inst_1 : AddAction G X] {N : AddSubgroup G} [N.Normal] (a : X),
AddAction.IsBlock G (AddAction.orbit (↥N) a) | An orbit of a normal subgroup is a block | true |
Matrix.instPartialOrder | Mathlib.Analysis.Matrix.Order | {𝕜 : Type u_1} → {n : Type u_2} → [RCLike 𝕜] → PartialOrder (Matrix n n 𝕜) | The partial order on matrices given by `A ≤ B := (B - A).PosSemidef`. | true |
UniformOnFun.instPseudoEMetricSpace._proof_5 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_1} {β : Type u_2} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖],
uniformity (UniformOnFun α β 𝔖) = ⨅ ε, ⨅ (_ : ε > 0), Filter.principal {p | edist p.1 p.2 < ε} | null | false |
ArithmeticFunction.instModule | Mathlib.NumberTheory.ArithmeticFunction.Defs | {R : Type u_1} →
{S : Type u_2} → [inst : Semiring R] → [inst_1 : AddCommMonoid S] → [Module R S] → Module R (ArithmeticFunction S) | null | true |
RingTheory.LinearMap._aux_Mathlib_Algebra_Algebra_Defs___unexpand_Algebra_linearMap_2 | Mathlib.Algebra.Algebra.Defs | Lean.PrettyPrinter.Unexpander | null | false |
MvPolynomial.aeval_expand | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) {A : Type u_5} [inst_1 : CommSemiring A]
[inst_2 : Algebra R A] (f : σ → A) (φ : MvPolynomial σ R),
(MvPolynomial.aeval f) ((MvPolynomial.expand p) φ) = (MvPolynomial.aeval (f ^ p)) φ | null | true |
CategoryTheory.MorphismProperty.precoverage_top | Mathlib.CategoryTheory.Sites.MorphismProperty | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C], ⊤.precoverage = ⊤ | null | true |
CategoryTheory.Limits.coneRightOpOfCoconeEquiv | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{F : CategoryTheory.Functor Jᵒᵖ C} → (CategoryTheory.Limits.Cocone F)ᵒᵖ ≌ CategoryTheory.Limits.Cone F.rightOp | Cocones on `F : Jᵒᵖ ⥤ C` are equivalent to cones on `F.rightOp : J ⥤ Cᵒᵖ`. | true |
_private.Mathlib.Data.Bool.Basic.0.Bool.injective_iff._proof_1_1 | Mathlib.Data.Bool.Basic | ∀ {α : Sort u_1} {f : Bool → α}, f false ≠ f true → ∀ (x y : Bool), f x = f y → x = y | null | false |
_private.Mathlib.LinearAlgebra.Pi.0.LinearEquiv.piOptionEquivProd._simp_1 | Mathlib.LinearAlgebra.Pi | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | null | false |
Set.orderIsoOfEq._proof_1 | Mathlib.Order.Hom.Set | ∀ {α : Type u_1} [inst : Preorder α] (s t : Set α) (h : s = t) {a b : ↑s},
(Set.equivOfEq h) a ≤ (Set.equivOfEq h) b ↔ (Set.equivOfEq h) a ≤ (Set.equivOfEq h) b | null | false |
_private.Mathlib.SetTheory.ZFC.Basic.0.ZFSet.regularity.match_1_1 | Mathlib.SetTheory.ZFC.Basic | ∀ (x z w : ZFSet.{u_1}) (motive : w ∈ x ∧ w ∈ z → Prop) (x_1 : w ∈ x ∧ w ∈ z),
(∀ (wx : w ∈ x) (wz : w ∈ z), motive ⋯) → motive x_1 | null | false |
Std.Http.Protocol.H1.Reader.State.closed.sizeOf_spec | Std.Http.Protocol.H1.Reader | ∀ {dir : Std.Http.Protocol.H1.Direction}, sizeOf Std.Http.Protocol.H1.Reader.State.closed = 1 | null | true |
Monotone.antitone_iterate_of_map_le | Mathlib.Order.Iterate | ∀ {α : Type u_1} [inst : Preorder α] {f : α → α} {x : α}, Monotone f → f x ≤ x → Antitone fun n => f^[n] x | If `f` is a monotone map and `f x ≤ x` at some point `x`, then the iterates `f^[n] x` form
an antitone sequence. | true |
lift_rank_range_le | Mathlib.LinearAlgebra.Dimension.Basic | ∀ {R : Type u} {M : Type v} {M' : Type v'} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid M'] [inst_4 : Module R M'] (f : M →ₗ[R] M'),
Cardinal.lift.{v, v'} (Module.rank R ↥f.range) ≤ Cardinal.lift.{v', v} (Module.rank R M) | The rank of the range of a linear map is at most the rank of the source. | true |
Nat.lt | Init.Prelude | ℕ → ℕ → Prop | Strict inequality of natural numbers, usually accessed via the `<` operator.
It is defined as `n < m = n + 1 ≤ m`.
| true |
_private.Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic.0.IsIntegral.of_pow.match_1_1 | Mathlib.RingTheory.IntegralClosure.IsIntegral.Basic | ∀ {R : Type u_1} {B : Type u_2} [inst : CommRing R] [inst_1 : Ring B] [inst_2 : Algebra R B] {x : B} {n : ℕ}
(motive : IsIntegral R (x ^ n) → Prop) (hx : IsIntegral R (x ^ n)),
(∀ (p : Polynomial R) (hmonic : p.Monic) (heval : Polynomial.eval₂ (algebraMap R B) (x ^ n) p = 0), motive ⋯) →
motive hx | null | false |
CategoryTheory.MonObj.mk | Mathlib.CategoryTheory.Monoidal.Mon | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
{X : C} →
(one : CategoryTheory.MonoidalCategoryStruct.tensorUnit C ⟶ X) →
(mul : CategoryTheory.MonoidalCategoryStruct.tensorObj X X ⟶ X) →
autoParam
(C... | null | true |
_private.Mathlib.Tactic.DefEqAbuse.0.Lean.MessageData.visitWithM | Mathlib.Tactic.DefEqAbuse | {m : Type → Type} →
[Monad m] →
{α : Type} →
{β : Type u_1} →
Array β →
(β → m α) →
autoParam α Lean.MessageData.visitWithM._auto_1✝ →
autoParam (α → α → α) Lean.MessageData.visitWithM._auto_3✝ → m α | Convenience wrapper which accumulates the results of `visitM` across `arr`, attempting to
produce `empty` and `combine` from `{}` and `(· ++ ·)` or `(· ∪ ·)`. | true |
Lean.Server.Ilean.rec | Lean.Server.References | {motive : Lean.Server.Ilean → Sort u} →
((version : ℕ) →
(module : Lean.Name) →
(directImports : Array Lean.Lsp.ImportInfo) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) →
motive
{ version := version, module := module, directImports :... | null | false |
_private.Mathlib.Tactic.DuplicateDecls.0.Mathlib.Tactic.DuplicateDecls.isAlias.isConstBVarApp._f | Mathlib.Tactic.DuplicateDecls | (a : Lean.Expr) → Lean.Expr.below a → Bool | null | false |
_private.Mathlib.Combinatorics.Matroid.Basic.0.Matroid.exists_isBasis.match_1_1 | Mathlib.Combinatorics.Matroid.Basic | ∀ {α : Type u_1} (M : Matroid α) (X : Set α) (motive : (∃ J, M.IsBasis J X ∧ ∅ ⊆ J) → Prop)
(x : ∃ J, M.IsBasis J X ∧ ∅ ⊆ J), (∀ (w : Set α) (hI : M.IsBasis w X) (right : ∅ ⊆ w), motive ⋯) → motive x | null | false |
Set.LeftInvOn.image_inter | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {s s₁ : Set α} {f : α → β} {f' : β → α},
Set.LeftInvOn f' f s → f '' (s₁ ∩ s) = f' ⁻¹' (s₁ ∩ s) ∩ f '' s | null | true |
Filter.Germ.LiftRel._proof_1 | Mathlib.Order.Filter.Germ.Basic | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {l : Filter α} (r : β → γ → Prop) (_f : α → β) (_g : α → γ) (_f' : α → β)
(_g' : α → γ),
(l.germSetoid β) _f _f' →
(l.germSetoid γ) _g _g' → (∀ᶠ (x : α) in l, r (_f x) (_g x)) = ∀ᶠ (x : α) in l, r (_f' x) (_g' x) | null | false |
ContinuousMultilinearMap.currySumEquiv._proof_11 | Mathlib.Analysis.Normed.Module.Multilinear.Curry | ∀ (𝕜 : Type u_1) (ι : Type u_2) (ι' : Type u_3) (G : Type u_4) (G' : Type u_5) [inst : Fintype ι] [inst_1 : Fintype ι']
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NormedAddCommGroup G] [inst_4 : NormedSpace 𝕜 G]
[inst_5 : NormedAddCommGroup G'] [inst_6 : NormedSpace 𝕜 G'] (f : ContinuousMultilinearMap 𝕜 (f... | null | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance.eq_def | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ (pat : String.Slice) (patByte : UInt8) (table : Array ℕ) (ht : table.size ≤ pat.utf8ByteSize)
(h : ∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) (guess : ℕ) (hg : guess < table.size),
String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance✝ pat patByte table ht h guess hg =
if pat.getUTF8Byte { ... | null | true |
CategoryTheory.Limits.image.lift_mk_comp._proof_3 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z)
[inst_1 : CategoryTheory.Limits.HasImage g] (h : Y ⟶ CategoryTheory.Limits.image g),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f h) (CategoryTheory.Limits.image.ι g) =
CategoryTheory... | null | false |
CategoryTheory.Limits.coprod.braiding_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts.BinaryProducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P Q : C)
[inst_1 : CategoryTheory.Limits.HasBinaryCoproduct P Q] [inst_2 : CategoryTheory.Limits.HasBinaryCoproduct Q P],
(CategoryTheory.Limits.coprod.braiding P Q).inv =
CategoryTheory.Limits.coprod.desc CategoryTheory.Limits.coprod.inr CategoryTheory.... | null | true |
PNat.XgcdType.flip_z | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.z = u.w | null | true |
LieSubmodule.mem_map_of_mem | Mathlib.Algebra.Lie.Submodule | ∀ {R : Type u} {L : Type v} {M : Type w} {M' : Type w₁} [inst : CommRing R] [inst_1 : LieRing L]
[inst_2 : AddCommGroup M] [inst_3 : Module R M] [inst_4 : LieRingModule L M] [inst_5 : AddCommGroup M']
[inst_6 : Module R M'] [inst_7 : LieRingModule L M'] {f : M →ₗ⁅R,L⁆ M'} {N : LieSubmodule R L M} {m : M},
m ∈ N →... | null | true |
Sum.smul_inl | Mathlib.Algebra.Group.Action.Sum | ∀ {M : Type u_1} {α : Type u_3} {β : Type u_4} [inst : SMul M α] [inst_1 : SMul M β] (a : M) (b : α),
a • Sum.inl b = Sum.inl (a • b) | null | true |
CategoryTheory.Limits.limitIsoLimitCurryCompLim | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
(G : CategoryTheory.Functor (J × K) C) →
[inst_3 : CategoryTheory... | The Fubini theorem for a functor `G : J × K ⥤ C`,
showing that the limit of `G` can be computed as
the limit of the limits of the functors `G.obj (j, _)`.
| true |
CategoryTheory.ChosenPullbacksAlong.cartesianMonoidalCategoryToUnit._proof_14 | Mathlib.CategoryTheory.LocallyCartesianClosed.ChosenPullbacksAlong | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
{X : C} (f : X ⟶ CategoryTheory.MonoidalCategoryStruct.tensorUnit C)
⦃X_1 Y : CategoryTheory.Over (CategoryTheory.MonoidalCategoryStruct.tensorUnit C)⦄ (f_1 : X_1 ⟶ Y),
CategoryTheory.CategoryStruc... | null | false |
_private.Lean.Compiler.ExternAttr.0.Lean.isExternC._sparseCasesOn_2 | Lean.Compiler.ExternAttr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.Data.List.Cycle.0.Cycle.Subsingleton.congr._simp_1_1 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {s : Cycle α}, s.Subsingleton = (s.length ≤ 1) | null | false |
_private.Mathlib.MeasureTheory.Function.Jacobian.0.ApproximatesLinearOn.norm_fderiv_sub_le._simp_1_1 | Mathlib.MeasureTheory.Function.Jacobian | ∀ {α : Type u_1} {β : Type u_2} [inst : SMul α β] {t : Set β} {a : α} {x : β}, (x ∈ a • t) = ∃ y ∈ t, a • y = x | null | false |
cantorSequence_eq_self_sub_sum_cantorToTernary | Mathlib.Topology.Instances.CantorSet | ∀ (x : ℝ) (n : ℕ),
(cantorSequence x).get n = (x - ∑ i ∈ Finset.range n, Real.ofDigitsTerm (cantorToTernary x).get i) * 3 ^ n | null | true |
Batteries.UnionFind.equiv_empty._simp_1 | Batteries.Data.UnionFind.Lemmas | ∀ {a b : ℕ}, Batteries.UnionFind.empty.Equiv a b = (a = b) | null | false |
ContinuousLinearMap.postcompContinuousAffineMap_apply | Mathlib.Topology.Algebra.ContinuousAffineMap.Topology | ∀ {R : Type u_1} {V : Type u_2} {W : Type u_3} {W₂ : Type u_4} (P : Type u_5) [inst : NormedField R]
[inst_1 : AddCommGroup V] [inst_2 : Module R V] [inst_3 : TopologicalSpace V] [inst_4 : AddTorsor V P]
[inst_5 : TopologicalSpace P] [inst_6 : AddCommGroup W] [inst_7 : Module R W] [inst_8 : TopologicalSpace W]
[i... | null | true |
instMetricSpaceEmpty._proof_5 | Mathlib.Topology.MetricSpace.Defs | ∀ (x x : Empty), 0 = 0 | null | false |
_private.Mathlib.RingTheory.RootsOfUnity.Complex.0.Complex.isPrimitiveRoot_exp_of_isCoprime._simp_1_1 | Mathlib.RingTheory.RootsOfUnity.Complex | ∀ (x : ℂ) (n : ℕ), Complex.exp x ^ n = Complex.exp (↑n * x) | null | false |
groupHomology.δ_apply | Mathlib.RepresentationTheory.Homological.GroupHomology.LongExactSequence | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] {X : CategoryTheory.ShortComplex (Rep.{u, u, u} k G)}
(hX : X.ShortExact) {i j : ℕ} (hij : j + 1 = i) (z : (Fin i → G) →₀ ↑X.X₃)
(hz : (CategoryTheory.ConcreteCategory.hom ((groupHomology.inhomogeneousChains X.X₃).d i j)) z = 0)
(y : (Fin i → G) →₀ ↑X.X₂),
... | null | true |
Std.DTreeMap.Internal.Impl.WF.casesOn | Std.Data.DTreeMap.Internal.WF.Defs | ∀ {α : Type u} [inst : Ord α] {motive : {β : α → Type v} → (a : Std.DTreeMap.Internal.Impl α β) → a.WF → Prop}
{β : α → Type v} {a : Std.DTreeMap.Internal.Impl α β} (t : a.WF),
(∀ {x : α → Type v} {t : Std.DTreeMap.Internal.Impl α x} (a : t.Balanced) (a_1 : ∀ [Std.TransOrd α], t.Ordered),
motive t ⋯) →
(∀... | null | false |
CategoryTheory.Limits.WalkingMulticospan.functorExt.match_1 | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | {J : CategoryTheory.Limits.MulticospanShape} →
(motive : CategoryTheory.Limits.WalkingMulticospan J → Sort u_3) →
(j : CategoryTheory.Limits.WalkingMulticospan J) →
((i : J.L) → motive (CategoryTheory.Limits.WalkingMulticospan.left i)) →
((i : J.R) → motive (CategoryTheory.Limits.WalkingMulticospan.... | null | false |
_private.Lean.Data.Options.0.Lean.Options.mk.inj | Lean.Data.Options | ∀ {map : Lean.NameMap Lean.DataValue} {hasTrace : Bool} {map_1 : Lean.NameMap Lean.DataValue} {hasTrace_1 : Bool},
{ map := map, hasTrace := hasTrace } = { map := map_1, hasTrace := hasTrace_1 } → map = map_1 ∧ hasTrace = hasTrace_1 | null | true |
Turing.TM2to1.StAct.casesOn | Mathlib.Computability.TuringMachine.StackTuringMachine | {K : Type u_1} →
{Γ : K → Type u_2} →
{σ : Type u_4} →
{k : K} →
{motive : Turing.TM2to1.StAct K Γ σ k → Sort u} →
(t : Turing.TM2to1.StAct K Γ σ k) →
((a : σ → Γ k) → motive (Turing.TM2to1.StAct.push a)) →
((a : σ → Option (Γ k) → σ) → motive (Turing.TM2to1.StAct... | null | false |
Std.Rcc.size_eq_ite_rcc | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} {r : Std.Rcc α} [inst : LE α] [inst_1 : DecidableLE α] [inst_2 : Std.PRange.UpwardEnumerable α]
[inst_3 : Std.Rxc.HasSize α] [Std.PRange.LawfulUpwardEnumerable α] [Std.PRange.LawfulUpwardEnumerableLE α]
[Std.Rxc.IsAlwaysFinite α] [Std.Rxc.LawfulHasSize α],
r.size =
if r.lower ≤ r.upper then
... | null | true |
UInt16.toNat_ofFin | Init.Data.UInt.Lemmas | ∀ (x : Fin UInt16.size), (UInt16.ofFin x).toNat = ↑x | null | true |
MeasureTheory.Measure.WeaklyRegular.recOn | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : μ.WeaklyRegular → Sort u} →
(t : μ.WeaklyRegular) →
([toOuterRegular : μ.OuterRegular] → (innerRegular : μ.InnerRegularWRT IsClosed IsOpen) → motive ⋯) →
... | null | false |
LinearIsometry.comp_continuous_iff._simp_1 | Mathlib.Analysis.Normed.Operator.LinearIsometry | ∀ {R : Type u_1} {R₂ : Type u_2} {E : Type u_4} {E₂ : Type u_5} [inst : Semiring R] [inst_1 : Semiring R₂]
{σ₁₂ : R →+* R₂} [inst_2 : SeminormedAddCommGroup E] [inst_3 : SeminormedAddCommGroup E₂] [inst_4 : Module R E]
[inst_5 : Module R₂ E₂] (f : E →ₛₗᵢ[σ₁₂] E₂) {α : Type u_9} [inst_6 : TopologicalSpace α] {g : α ... | null | false |
CategoryTheory.ShortComplex.toCyclesNatTrans | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
[inst_2 : CategoryTheory.Limits.HasKernels C] →
[inst_3 : CategoryTheory.Limits.HasCokernels C] →
CategoryTheory.ShortComplex.π₁ ⟶ CategoryTheory.ShortComplex.cyclesFuncto... | The natural transformation `S.X₁ ⟶ S.cycles` for all short complexes `S`. | true |
LieAlgebra.SpecialLinear.val_single | Mathlib.Algebra.Lie.Classical | ∀ {n : Type u_1} {R : Type u₂} [inst : CommRing R] [inst_1 : DecidableEq n] [inst_2 : Fintype n] (i j : n) (h : i ≠ j)
(r : R), ↑((LieAlgebra.SpecialLinear.single i j h) r) = Matrix.single i j r | null | true |
Task.get | Init.Core | {α : Type u} → Task α → α | Blocks the current thread until the given task has finished execution, and then returns the result
of the task. If the current thread is itself executing a (non-dedicated) task, the maximum
threadpool size is temporarily increased by one while waiting so as to ensure the process cannot
be deadlocked by threadpool starv... | true |
FinPartOrd._sizeOf_1 | Mathlib.Order.Category.FinPartOrd | FinPartOrd → ℕ | null | false |
geom_sum_mul_of_le_one | Mathlib.Algebra.Ring.GeomSum | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [AddLeftReflectLE R] [AddLeftMono R]
[ExistsAddOfLE R] [inst_5 : Sub R] [OrderedSub R] {x : R},
x ≤ 1 → ∀ (n : ℕ), (∑ i ∈ Finset.range n, x ^ i) * (1 - x) = 1 - x ^ n | null | true |
_private.Mathlib.RingTheory.PowerSeries.Substitution.0.PowerSeries.substInvFun.match_1.splitter | Mathlib.RingTheory.PowerSeries.Substitution | (motive : ℕ → Sort u_1) →
(x : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((n : ℕ) → (n = 0 → False) → motive n.succ) → motive x | null | true |
AlgebraicGeometry.instIsOpenImmersionMapScheme | Mathlib.AlgebraicGeometry.Morphisms.OpenImmersion | ∀ {X Y X' Y' : AlgebraicGeometry.Scheme} (f : X ⟶ X') (g : Y ⟶ Y') [AlgebraicGeometry.IsOpenImmersion f]
[AlgebraicGeometry.IsOpenImmersion g], AlgebraicGeometry.IsOpenImmersion (CategoryTheory.Limits.coprod.map f g) | null | true |
cfc_nonneg_of_predicate._simp_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [inst_9 : LE A]
[inst_10 : ContinuousFunctionalCalculus... | null | false |
TrivSqZeroExt.kerIdeal._proof_1 | Mathlib.Algebra.TrivSqZeroExt.Ideal | ∀ (R : Type u_1) (M : Type u_2) [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Module Rᵐᵒᵖ M] [IsCentralScalar R M], SMulCommClass R Rᵐᵒᵖ M | null | false |
_private.Batteries.Data.String.Lemmas.0.Substring.Raw.ValidFor.of_eq.match_1_1 | Batteries.Data.String.Lemmas | ∀ {l m r : List Char}
(motive :
(x : Substring.Raw) →
x.str.toList = l ++ m ++ r →
x.startPos.byteIdx = String.utf8Len l → x.stopPos.byteIdx = String.utf8Len l + String.utf8Len m → Prop)
(x : Substring.Raw) (x_1 : x.str.toList = l ++ m ++ r) (x_2 : x.startPos.byteIdx = String.utf8Len l)
(x_3 : x... | null | false |
CochainComplex.mappingCone.trianglehMapOfHomotopy_hom₂ | Mathlib.Algebra.Homology.HomotopyCategory.Pretriangulated | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasBinaryBiproducts C] {K₁ L₁ K₂ L₂ : CochainComplex C ℤ} {φ₁ : K₁ ⟶ L₁}
{φ₂ : K₂ ⟶ L₂} {a : K₁ ⟶ K₂} {b : L₁ ⟶ L₂}
(H : Homotopy (CategoryTheory.CategoryStruct.comp φ₁ b) (Catego... | null | true |
Std.TreeSet.get!_ofList_of_mem | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : Inhabited α] {l : List α} {k k' : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.ofList l cmp).get! k' = k | null | true |
WithZero.decidableEq | Mathlib.Algebra.Order.GroupWithZero.Canonical | {α : Type u_1} → [DecidableEq α] → DecidableEq (WithZero α) | null | true |
Mathlib.Tactic.Algebra.pushCast | Mathlib.Tactic.Algebra.Basic | Lean.Expr → Lean.MetaM Lean.Meta.Simp.Result | Push `algebraMap`s into sums and products and convert `algebraMap`s from `ℕ`, `ℤ` and `ℚ`
into casts. | true |
Lean.Compiler.LCNF.CodeDecl.collectUsed | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} → Lean.Compiler.LCNF.CodeDecl pu → optParam Lean.FVarIdHashSet ∅ → Lean.FVarIdHashSet | null | true |
Function.Injective.isLeftCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsLeftCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsLeftCancelAdd M₁ | A type has left-cancellative addition, if it admits an injective map that
preserves `+` to another type with left-cancellative addition. | true |
Order.Frame.toDistribLattice._proof_1 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_1} [inst : Order.Frame α] (a b c : α), a ⊓ (b ⊔ c) ≤ a ⊓ b ⊔ a ⊓ c | null | false |
List.toFinset_filter | Mathlib.Data.Finset.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] (s : List α) (p : α → Bool),
(List.filter p s).toFinset = {x ∈ s.toFinset | p x = true} | null | true |
SSet.horn_ι_mem_innerHornInclusions | Mathlib.AlgebraicTopology.Quasicategory.InnerFibration | ∀ {n : ℕ} {i : Fin (n + 1)}, 0 < i → i < Fin.last n → SSet.innerHornInclusions (SSet.horn n i).ι | null | true |
Subgroup.isFiniteRelIndex_map_powMonoidHom_of_fg | Mathlib.GroupTheory.FiniteAbelian.Basic | ∀ {A : Type u_1} [inst : CommGroup A] {B : Subgroup A},
B.FG → ∀ {n : ℕ}, n ≠ 0 → (Subgroup.map (powMonoidHom n) B).IsFiniteRelIndex B | null | true |
Aesop.Frontend.instInhabitedPriority.default | Aesop.Frontend.RuleExpr | Aesop.Frontend.Priority | null | true |
Real.sin_add_nat_mul_two_pi | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℝ) (n : ℕ), Real.sin (x + ↑n * (2 * Real.pi)) = Real.sin x | null | true |
UInt8.pow.match_1 | Init.Data.UInt.Basic | (motive : ℕ → Sort u_1) → (n : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive n | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem.0.ValueDistribution.abs_characteristic_sub_characteristic_shift_le._simp_1_2 | Mathlib.Analysis.Complex.ValueDistribution.FirstMainTheorem | ∀ {G : Type u_1} [inst : AddSemigroup G] (a b c : G), a + (b + c) = a + b + c | null | false |
ZFSet.diff | Mathlib.SetTheory.ZFC.Basic | ZFSet.{u} → ZFSet.{u} → ZFSet.{u} | The set difference operation | true |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.PreprocessKind.recOn | Lean.Meta.SynthInstance | {motive : Lean.Meta.PreprocessKind✝ → Sort u} →
(t : Lean.Meta.PreprocessKind✝) →
motive Lean.Meta.PreprocessKind.noMVars✝ →
motive Lean.Meta.PreprocessKind.mvarsNoOutputParams✝ →
motive Lean.Meta.PreprocessKind.mvarsOutputParams✝ → motive t | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.