name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Std.DHashMap.Raw.contains_diff | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Raw α β} [EquivBEq α]
[LawfulHashable α], m₁.WF → m₂.WF → ∀ {k : α}, (m₁ \ m₂).contains k = (m₁.contains k && !m₂.contains k) | null | true |
BaseIO.toIO | Init.System.IO | {α : Type} → BaseIO α → IO α | Runs a `BaseIO` action, which cannot throw an exception, as an `IO` action.
This function is usually used implicitly via [automatic monadic
lifting](https://lean-lang.org/doc/reference/4.35.0/find/?domain=Verso.Genre.Manual.section&name=lifting-monads) rather than being called explicitly.
| true |
Std.Do.PredTrans._sizeOf_1 | Std.Do.PredTrans | {ps : Std.Do.PostShape} → {α : Type u} → [SizeOf α] → Std.Do.PredTrans ps α → ℕ | null | false |
_private.Lean.Compiler.LCNF.SimpleGroundExpr.0.Lean.Compiler.LCNF.compileToSimpleGroundExpr.compileNonFinalLet._sparseCasesOn_3 | Lean.Compiler.LCNF.SimpleGroundExpr | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
_private.Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter.0.CategoryTheory.SimplicialObject.δ_δ₀Iter'._simp_1_1 | Mathlib.AlgebraicTopology.SimplicialObject.DeltaZeroIter | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(self : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (self.map f) (self.map g) = self.map (CategoryTheory.CategoryStruct.comp f g) | null | false |
CategoryTheory.DifferentialObject.Hom._sizeOf_inst | Mathlib.CategoryTheory.DifferentialObject | {S : Type u_1} →
{inst : AddMonoidWithOne S} →
{C : Type u} →
{inst_1 : CategoryTheory.Category.{v, u} C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{inst_3 : CategoryTheory.HasShift C S} →
(X Y : CategoryTheory.DifferentialObject S C) → [SizeOf S] → [SizeOf C] → S... | null | false |
DvdNotUnit.eq_1 | Mathlib.Algebra.GroupWithZero.Associated | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] (a b : α), DvdNotUnit a b = (a ≠ 0 ∧ ∃ x, ¬IsUnit x ∧ b = a * x) | null | true |
AlgebraicGeometry.HasRingHomProperty.of_isOpenImmersion | Mathlib.AlgebraicGeometry.Morphisms.RingHomProperties | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme}
{Q : {R S : Type u} → [inst : CommRing R] → [inst_1 : CommRing S] → (R →+* S) → Prop}
[AlgebraicGeometry.HasRingHomProperty P Q] {X Y : AlgebraicGeometry.Scheme} {f : X ⟶ Y},
(RingHom.ContainsIdentities fun {R S} [CommRing R] [CommRing S] => Q) → ∀ ... | null | true |
_private.Mathlib.Algebra.Order.Ring.Abs.0.geomSum.match_1 | Mathlib.Algebra.Order.Ring.Abs | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | null | false |
Std.Tactic.BVDecide.BVExpr.Cache.Inv_empty | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Expr | ∀ {assign : Std.Tactic.BVDecide.BVExpr.Assignment} (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit),
Std.Tactic.BVDecide.BVExpr.Cache.Inv assign aig Std.Tactic.BVDecide.BVExpr.Cache.empty | null | true |
List.not_lex_nil | Init.Data.List.Lex | ∀ {α : Type u_1} {r : α → α → Prop} {l : List α}, ¬List.Lex r l [] | null | true |
_private.Lean.Elab.Tactic.BuiltinTactic.0.Lean.Elab.Tactic.evalRotateLeft._regBuiltin.Lean.Elab.Tactic.evalRotateLeft_1 | Lean.Elab.Tactic.BuiltinTactic | IO Unit | null | false |
_private.Mathlib.Data.ZMod.Defs.0.Fin.val_intCast._proof_1_2 | Mathlib.Data.ZMod.Defs | ∀ (x : ℤ), ¬0 ≤ x → x < 0 | null | false |
CoxeterSystem.IsReduced.drop | Mathlib.GroupTheory.Coxeter.Length | ∀ {B : Type u_1} {W : Type u_2} [inst : Group W] {M : CoxeterMatrix B} {cs : CoxeterSystem M W} {ω : List B},
cs.IsReduced ω → ∀ (j : ℕ), cs.IsReduced (List.drop j ω) | null | true |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.restriction.res | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | {C₀ : Type u₀} →
{C : Type u} →
[inst : CategoryTheory.Category.{v₀, u₀} C₀] →
[inst_1 : CategoryTheory.Category.{v, u} C] →
{F : CategoryTheory.Functor C₀ C} →
{J₀ : CategoryTheory.GrothendieckTopology C₀} →
{J : CategoryTheory.GrothendieckTopology C} →
{A : Type... | Auxiliary definition for `OneHypercoverDenseData.essSurj.restriction`. | true |
Lean.IR.IRType.void | Lean.Compiler.IR.Basic | Lean.IR.IRType | null | true |
PrincipalSeg.codRestrict._proof_4 | Mathlib.Order.InitialSeg | ∀ {α : Type u_2} {β : Type u_1} {r : α → α → Prop} {s : β → β → Prop} (p : Set β) (f : PrincipalSeg r s)
(H : ∀ (a : α), f.toRelEmbedding a ∈ p) (H₂ : f.top ∈ p) (val : β) (property : val ∈ p),
⟨val, property⟩ ∈ Set.range ⇑(RelEmbedding.codRestrict p f.toRelEmbedding H) ↔
Subrel s (fun x => x ∈ p) ⟨val, propert... | null | false |
IsUnit.inv_mul_cancel | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : DivisionMonoid α] {a : α}, IsUnit a → a⁻¹ * a = 1 | null | true |
InnerProductSpace.isIdempotentElem_rankOne_self_iff | Mathlib.Analysis.InnerProductSpace.LinearMap | ∀ {𝕜 : Type u_4} [inst : RCLike 𝕜] {F : Type u_8} [inst_1 : NormedAddCommGroup F] [inst_2 : InnerProductSpace 𝕜 F]
{x : F}, x ≠ 0 → (IsIdempotentElem (((InnerProductSpace.rankOne 𝕜) x) x) ↔ ‖x‖ = 1) | null | true |
CategoryTheory.Triangulated.TStructure.truncGE_map_truncGEπ_app_assoc | Mathlib.CategoryTheory.Triangulated.TStructure.TruncLTGE | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] [inst_3 : CategoryTheory.HasShift C ℤ]
[inst_4 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_5 : CategoryTheory.Pretriangulated C]
(t : CategoryTheory.... | null | true |
ChainCompletePartialOrder.casesOn | Mathlib.Order.BourbakiWitt | {α : Type u_4} →
{motive : ChainCompletePartialOrder α → Sort u} →
(t : ChainCompletePartialOrder α) →
([toPartialOrder : PartialOrder α] →
(cSup : NonemptyChain α → α) →
(le_cSup : ∀ (c : NonemptyChain α), ∀ x ∈ c.carrier, x ≤ cSup c) →
(cSup_le : ∀ (c : NonemptyChain α)... | null | false |
Finset.prod_lt_prod_of_subset | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {M : Type u_4} [inst : CommMonoid M] [inst_1 : Preorder M] [IsOrderedCancelMonoid M] {f : ι → M}
{s t : Finset ι} [MulLeftStrictMono M],
s ⊆ t → ∀ {i : ι}, i ∈ t → i ∉ s → 1 < f i → (∀ j ∈ t, j ∉ s → 1 ≤ f j) → ∏ j ∈ s, f j < ∏ j ∈ t, f j | null | true |
IsLowerSet.eq_univ_or_Iio | Mathlib.Order.UpperLower.Basic | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α} [WellFoundedLT α], IsLowerSet s → s = Set.univ ∨ ∃ a, s = Set.Iio a | null | true |
_private.Mathlib.CategoryTheory.Subfunctor.Basic.0.CategoryTheory.Subfunctor.ext.match_1 | Mathlib.CategoryTheory.Subfunctor.Basic | ∀ {C : Type u_3} {inst : CategoryTheory.Category.{u_2, u_3} C} {F : CategoryTheory.Functor C (Type u_1)}
(motive : CategoryTheory.Subfunctor F → Prop) (h : CategoryTheory.Subfunctor F),
(∀ (obj : (U : C) → Set (F.obj U))
(map : ∀ {U V : C} (i : U ⟶ V), obj U ⊆ ⇑(CategoryTheory.ConcreteCategory.hom (F.map i)) ... | null | false |
FiniteAddGrp.mk._flat_ctor | Mathlib.Algebra.Category.Grp.FiniteGrp | (toAddGrp : AddGrpCat) → [isFinite : Finite ↑toAddGrp] → FiniteAddGrp.{u} | null | false |
CategoryTheory.Abelian.SpectralObject.rightHomologyDataShortComplex._proof_2 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {j k l : ι} (f₂ : j ⟶ k) (f₃ : k ⟶ l) (n₀ n₁ : ℤ) (hn₁ : n₀ + 1 = n₁),
CategoryTheory.CategoryStruct.com... | null | false |
Subrepresentation.mem_ofSubmodule_iff | Mathlib.RepresentationTheory.Subrepresentation | ∀ {A : Type u_1} {G : Type u_2} {M : Type u_4} [inst : CommSemiring A] [inst_1 : Monoid G] [inst_2 : AddCommMonoid M]
[inst_3 : Module (MonoidAlgebra A G) M] {N : Submodule (MonoidAlgebra A G) M} {m : M},
m ∈ Subrepresentation.ofSubmodule N ↔ m ∈ N | null | true |
CategoryTheory.Pseudofunctor.DescentData.instCategory._proof_7 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_3, u_5} C]
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} {ι : Type u_1} {S : C}
{X : ι → C} {f : (i : ι) → X i ⟶ S} {X_1 Y : F.DescentData f} (f_1 : X_1.Hom Y),
{
hom := fun i =>
CategoryTheory.CategoryS... | null | false |
Multiset.toDFinsupp_singleton | Mathlib.Data.DFinsupp.Multiset | ∀ {α : Type u_1} [inst : DecidableEq α] (a : α), Multiset.toDFinsupp {a} = fun₀ | a => 1 | null | true |
Nat.Partrec'.idv | Mathlib.Computability.PartrecBasis | ∀ {n : ℕ}, Nat.Partrec'.Vec id | null | true |
Complex.tan_pi_sub | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | ∀ (x : ℂ), Complex.tan (↑Real.pi - x) = -Complex.tan x | null | true |
Std.Time.TimeZone.LocalTimeType.identifier | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.LocalTimeType → String | ID of the timezone
| true |
Equiv.Perm.pow_apply_eq_of_apply_apply_eq_self._f | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} {f : Equiv.Perm α} {x : α},
f (f x) = x → ∀ (x_1 : ℕ) (f_1 : Nat.below x_1), (f ^ x_1) x = x ∨ (f ^ x_1) x = f x | null | false |
_private.Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred.0.Std.Tactic.BVDecide.BVPred.bitblast.match_7.eq_1 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Pred | ∀ (motive : Std.Tactic.BVDecide.BVPred → Sort u_1) (w : ℕ) (lhs : Std.Tactic.BVDecide.BVExpr w)
(op : Std.Tactic.BVDecide.BVBinPred) (rhs : Std.Tactic.BVDecide.BVExpr w)
(h_1 :
(w : ℕ) →
(lhs : Std.Tactic.BVDecide.BVExpr w) →
(op : Std.Tactic.BVDecide.BVBinPred) →
(rhs : Std.Tactic.BVDec... | null | true |
PrimeSpectrum.basicOpen_le_basicOpen_iff | Mathlib.RingTheory.Spectrum.Prime.Topology | ∀ {R : Type u} [inst : CommSemiring R] (f g : R),
PrimeSpectrum.basicOpen f ≤ PrimeSpectrum.basicOpen g ↔ f ∈ (Ideal.span {g}).radical | null | true |
LinearMap.BilinForm.apply_dualBasis_right | Mathlib.LinearAlgebra.BilinearForm.Properties | ∀ {V : Type u_5} {K : Type u_6} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V] {ι : Type u_9}
[inst_3 : DecidableEq ι] [inst_4 : Finite ι] {B : LinearMap.BilinForm K V} (hB : B.Nondegenerate),
B.IsSymm → ∀ (b : Module.Basis ι K V) (i j : ι), (B (b i)) ((B.dualBasis hB b) j) = if i = j then 1 else ... | null | true |
CategoryTheory.ShortComplex.opcyclesIsoCokernel_inv | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasRightHomology] [inst_3 : CategoryTheory.Limits.HasCokernel S.f],
S.opcyclesIsoCokernel.inv = CategoryTheory.Limits.cokernel.desc S.f S.pOpcycles ⋯ | null | true |
_private.Mathlib.Algebra.Lie.Extension.0.LieAlgebra.instOfTwoCocycle._simp_1 | Mathlib.Algebra.Lie.Extension | ∀ {M : Type u_1} {A : Type u_7} [inst : AddZeroClass A] [inst_1 : DistribSMul M A] (a : M) (b₁ b₂ : A),
a • b₁ + a • b₂ = a • (b₁ + b₂) | null | false |
_private.Mathlib.Order.Bounds.Basic.0.bddBelow_bddAbove_iff_subset_Icc._simp_1_1 | Mathlib.Order.Bounds.Basic | ∀ {α : Type u} {s t r : Set α}, (r ⊆ s ∩ t) = (r ⊆ s ∧ r ⊆ t) | null | false |
Lean.Meta.Grind.Arith.CommRing.CommRing.casesOn | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {motive : Lean.Meta.Grind.Arith.CommRing.CommRing → Sort u} →
(t : Lean.Meta.Grind.Arith.CommRing.CommRing) →
((toRing : Lean.Meta.Grind.Arith.CommRing.Ring) →
(invFn? : Option Lean.Expr) →
(semiringId? : Option ℕ) →
(commSemiringInst commRingInst : Lean.Expr) →
(noZero... | null | false |
Std.Http.Request.Head.rec | Std.Http.Data.Request | {motive : Std.Http.Request.Head → Sort u} →
((method : Std.Http.Method) →
(version : Std.Http.Version) →
(uri : Std.Http.RequestTarget) →
(headers : Std.Http.Headers) →
motive { method := method, version := version, uri := uri, headers := headers }) →
(t : Std.Http.Request.Head... | null | false |
Int8.toISize_toInt64 | Init.Data.SInt.Lemmas | ∀ (n : Int8), n.toInt64.toISize = n.toISize | null | true |
Part.omegaCompletePartialOrder._proof_1 | Mathlib.Order.OmegaCompletePartialOrder | ∀ {α : Type u_1} (c : OmegaCompletePartialOrder.Chain (Part α)) (i : ℕ), c i ≤ Part.ωSup c | null | false |
AlgebraicGeometry.Scheme.Cover.LocallyDirected.trans_comp._autoParam | Mathlib.AlgebraicGeometry.Cover.Directed | Lean.Syntax | null | false |
Mathlib.Explode.Status.sintro.elim | Mathlib.Tactic.Explode.Datatypes | {motive : Mathlib.Explode.Status → Sort u} →
(t : Mathlib.Explode.Status) → t.ctorIdx = 0 → motive Mathlib.Explode.Status.sintro → motive t | null | false |
Lean.CodeAction.FindTacticResult.rec | Lean.Server.CodeActions.Provider | {motive : Lean.CodeAction.FindTacticResult → Sort u} →
((a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tactic a)) →
((preferred : Bool) →
(insertIdx : ℕ) →
(a : Lean.Syntax.Stack) → motive (Lean.CodeAction.FindTacticResult.tacticSeq preferred insertIdx a)) →
(t : Lean.C... | null | false |
Ideal.Quotient.stabilizerHomSurjectiveAuxFunctor_aux | Mathlib.RingTheory.Invariant.Profinite | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B] {G : Type u}
[inst_3 : Group G] [inst_4 : MulSemiringAction G B] [inst_5 : SMulCommClass G A B] [inst_6 : TopologicalSpace G]
(Q : Ideal B) {N N' : OpenNormalSubgroup G} (e : N ≤ N'),
∀ x ∈ MulAction.stabilizer (G ⧸ ↑... | null | true |
isCoprime_mul_unit_right_left | Mathlib.RingTheory.Coprime.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] {x : R}, IsUnit x → ∀ (y z : R), IsCoprime (y * x) z ↔ IsCoprime y z | null | true |
HereditarilyLindelofSpace.isHereditarilyLindelof_univ | Mathlib.Topology.Compactness.Lindelof | ∀ {X : Type u_2} {inst : TopologicalSpace X} [self : HereditarilyLindelofSpace X], IsHereditarilyLindelof Set.univ | In a Hereditarily Lindelöf space, `Set.univ` is a Hereditarily Lindelöf set. | true |
Set.finrank_empty | Mathlib.LinearAlgebra.Dimension.Finite | ∀ {R : Type u} {M : Type v} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] [Nontrivial R],
Set.finrank R ∅ = 0 | null | true |
Lean.Meta.Tactic.TryThis.format.inputWidth | Lean.Meta.TryThis | Lean.Option ℕ | An option allowing the user to customize the ideal input width. Defaults to 100.
This option controls output format when
the output is intended to be copied back into a lean file | true |
Lean.Grind.CommRing.instBEqExpr.beq._sparseCasesOn_6 | Init.Grind.Ring.CommSolver | {motive : Lean.Grind.CommRing.Expr → Sort u} →
(t : Lean.Grind.CommRing.Expr) →
((a b : Lean.Grind.CommRing.Expr) → motive (a.add b)) → (Nat.hasNotBit 32 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.hasExt_iff | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C],
CategoryTheory.HasExt C ↔
∀ (X Y : C) (n : ℤ),
0 ≤ n →
Small.{w, w'}
((DerivedCategory.singleFunctor C 0).obj X ⟶
(CategoryTheory.shiftFunctor (Derive... | null | true |
Tactic.ComputeAsymptotics.MultiseriesExpansion.IsZero | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Trimming | {basis : Tactic.ComputeAsymptotics.Basis} → Tactic.ComputeAsymptotics.MultiseriesExpansion basis → Prop | A multiseries is zero if it is the real constant `0` or has an empty sequence. | true |
_private.Mathlib.Algebra.Group.Subgroup.Basic.0.Subgroup.mem_normalizer_iff_conj_image_eq._simp_1_7 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {α : Sort u_1} {p : α → Prop} {a' : α}, (∃ a, p a ∧ a = a') = p a' | null | false |
EMetric.pair_reduction | Mathlib.Topology.EMetricSpace.PairReduction | ∀ {T : Type u_1} [inst : TopologicalSpace T] [inst_1 : WeakPseudoEMetricSpace T] {a : ENNReal} {n : ℕ} {J : Finset T},
↑J.card ≤ a ^ n →
∀ (c : ENNReal) (E : Type u_2) [inst_2 : TopologicalSpace E] [inst_3 : WeakPseudoEMetricSpace E],
∃ K ⊆ J ×ˢ J,
↑K.card ≤ a * ↑J.card ∧
(∀ (s t : T), (s,... | **Pair Reduction**: Given pseudometric spaces `T` and `E`, `c ≥ 0`, and a finite subset `J` of
`T` such that `|J| ≤ aⁿ` for some `a ≥ 0` and `n : ℕ`, `pair_reduction` states that there exists a
set `K ⊆ J²` such that for any function `f : T → E`:
1. `|K| ≤ a|J|`
2. `∀ (s, t) ∈ K, d(s, t) ≤ cn`
3. `sup_{s, t ∈ J : d(s, ... | true |
Nat.AtLeastTwo.ne_one | Mathlib.Data.Nat.Init | ∀ {n : ℕ} [n.AtLeastTwo], n ≠ 1 | null | true |
CategoryTheory.kernelCokernelCompSequence.snakeInput_v₁₂_τ₃ | Mathlib.CategoryTheory.Abelian.DiagramLemmas.KernelCokernelComp | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X Y Z : C} (f : X ⟶ Y)
(g : Y ⟶ Z), (CategoryTheory.kernelCokernelCompSequence.snakeInput f g).v₁₂.τ₃ = g | null | true |
_private.Lean.Elab.DocString.0.Lean.Doc.ArgSpec.ctorElim | Lean.Elab.DocString | {motive : Lean.Doc.ArgSpec✝ → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Doc.ArgSpec✝) → ctorIdx = Lean.Doc.ArgSpec.ctorIdx✝ t → Lean.Doc.ArgSpec.ctorElimType✝ ctorIdx → motive t | null | false |
instOfNatFloat | Init.Data.OfScientific | {n : ℕ} → OfNat Float n | null | true |
CategoryTheory.HasCodetector.casesOn | Mathlib.CategoryTheory.Generator.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.HasCodetector C → Sort u} →
(t : CategoryTheory.HasCodetector C) →
((hasCodetector : ∃ G, CategoryTheory.IsCodetector G) → motive ⋯) → motive t | null | false |
hasDerivWithinAt_congr_set' | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f : 𝕜 → F} {f' : F} {x : 𝕜} {s t : Set 𝕜} (y : 𝕜),
s =ᶠ[nhdsWithin x {y}ᶜ] t → (HasDerivWithinAt f f' s x ↔ HasDerivWithinAt f f' t x) | null | true |
Array.zip_eq_zipWith | Init.Data.Array.Zip | ∀ {α : Type u_1} {β : Type u_2} {as : Array α} {bs : Array β}, as.zip bs = Array.zipWith Prod.mk as bs | null | true |
_private.Mathlib.LinearAlgebra.BilinearForm.Orthogonal.0.LinearMap.BilinForm.ker_restrict_eq_of_codisjoint._simp_1_1 | Mathlib.LinearAlgebra.BilinearForm.Orthogonal | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [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₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
Lean.Elab.SyntaxDeprecationEntry.mk.injEq | Lean.Elab.DeprecatedSyntax | ∀ (kind : Lean.SyntaxNodeKind) (text? since? : Option String) (kind_1 : Lean.SyntaxNodeKind)
(text?_1 since?_1 : Option String),
({ kind := kind, text? := text?, since? := since? } = { kind := kind_1, text? := text?_1, since? := since?_1 }) =
(kind = kind_1 ∧ text? = text?_1 ∧ since? = since?_1) | null | true |
_private.Std.Data.DHashMap.Internal.AssocList.Basic.0.Std.DHashMap.Internal.AssocList.map.go._sunfold | Std.Data.DHashMap.Internal.AssocList.Basic | {α : Type u} →
{β : α → Type v} →
{γ : α → Type w} →
((a : α) → β a → γ a) →
Std.DHashMap.Internal.AssocList α γ → Std.DHashMap.Internal.AssocList α β → Std.DHashMap.Internal.AssocList α γ | null | false |
Fin.partialSum | Mathlib.Algebra.BigOperators.Fin | {M : Type u_2} → [AddMonoid M] → {n : ℕ} → (Fin n → M) → Fin (n + 1) → M | For `f = (a₁, ..., aₙ)` in `αⁿ`, `partialSum f` is
`(0, a₁, a₁ + a₂, ..., a₁ + ... + aₙ)` in `αⁿ⁺¹`. | true |
List.map_rightInverse_iff._simp_1 | Mathlib.Data.List.Basic | ∀ {α : Type u} {β : Type v} {f : α → β} {g : β → α},
Function.RightInverse (List.map f) (List.map g) = Function.RightInverse f g | null | false |
_private.Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings.0.NumberField.Embeddings.finite_of_norm_le._simp_1_1 | Mathlib.NumberTheory.NumberField.InfinitePlace.Embeddings | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | null | false |
Lean.CollectLevelParams.State.visitedLevel | Lean.Util.CollectLevelParams | Lean.CollectLevelParams.State → Lean.LevelSet | null | true |
CategoryTheory.MorphismProperty.instHasTwoOutOfThreePropertyOppositeOp | Mathlib.CategoryTheory.MorphismProperty.Composition | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (W : CategoryTheory.MorphismProperty C)
[W.HasTwoOutOfThreeProperty], W.op.HasTwoOutOfThreeProperty | null | true |
Std.Internal.ForIn.toList_ric | Std.Internal.ForIn.Lemmas | ∀ {α : Type u} [inst : Std.PRange.Least? α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[inst_3 : Std.PRange.UpwardEnumerable α] [inst_4 : Std.Rxc.IsAlwaysFinite α]
[inst_5 : Std.PRange.LawfulUpwardEnumerable α] [inst_6 : Std.PRange.LawfulUpwardEnumerableLeast? α]
[inst_7 : Std.PRange.LawfulUpwardEnumerableLE α] (r ... | null | true |
IsometryClass.mk | Mathlib.Topology.MetricSpace.Isometry | ∀ {F : Type u_3} {α : outParam (Type u_4)} {β : outParam (Type u_5)} [inst : PseudoEMetricSpace α]
[inst_1 : PseudoEMetricSpace β] [inst_2 : FunLike F α β], (∀ (f : F), Isometry ⇑f) → IsometryClass F α β | null | true |
_private.Std.Data.Iterators.Lemmas.Combinators.TakeWhile.0.Std.Iter.step_takeWhile.match_3.eq_2 | Std.Data.Iterators.Lemmas.Combinators.TakeWhile | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(h : it.IsPlausibleStep (Std.IterStep.skip it'))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩)
(h_2... | null | true |
Lean.Server.Reference.mk._flat_ctor | Lean.Server.References | Lean.Lsp.RefIdent →
Array Lean.Lsp.RefIdent →
Lean.Lsp.Range → Lean.Syntax → Lean.Elab.ContextInfo → Lean.Elab.Info → Bool → Lean.Server.Reference | null | false |
Array.getElem_zipWith | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {xs : Array α} {ys : Array β} {f : α → β → γ} {i : ℕ}
(hi : i < (Array.zipWith f xs ys).size), (Array.zipWith f xs ys)[i] = f xs[i] ys[i] | null | true |
CategoryTheory.Discrete.monoidal._proof_8 | Mathlib.CategoryTheory.Monoidal.Discrete | ∀ (M : Type u_1) [inst : Monoid M] {X₁ Y₁ Z₁ X₂ Y₂ Z₂ : CategoryTheory.Discrete M} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂)
(g₁ : Y₁ ⟶ Z₁) (g₂ : Y₂ ⟶ Z₂),
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (CategoryTheory.eqToHom ⋯) = CategoryTheory.eqToHom ⋯ | null | false |
_private.Aesop.Tree.Data.0.Aesop.NodeState.isIrrelevant.match_1 | Aesop.Tree.Data | (motive : Aesop.NodeState → Sort u_1) →
(x : Aesop.NodeState) →
(Unit → motive Aesop.NodeState.proven) →
(Unit → motive Aesop.NodeState.unprovable) → (Unit → motive Aesop.NodeState.unknown) → motive x | null | false |
continuousOn_cfcₙ._auto_3 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Continuity | Lean.Syntax | null | false |
Matrix.addZeroClass | Mathlib.LinearAlgebra.Matrix.Defs | {m : Type u_2} → {n : Type u_3} → {α : Type v} → [AddZeroClass α] → AddZeroClass (Matrix m n α) | null | true |
_private.Mathlib.Topology.IndicatorConstPointwise.0.tendsto_indicator_const_apply_iff_eventually'._simp_1_1 | Mathlib.Topology.IndicatorConstPointwise | ∀ {α : Type u_1} {f g : Filter α}, (f ≤ g) = ∀ x ∈ g, x ∈ f | null | false |
Lean.ParseImports.State.mk.sizeOf_spec | Lean.Elab.ParseImportsFast | ∀ (imports : Array Lean.Import) (pos : String.Pos.Raw) (badModifier : Bool) (error? : Option String)
(isModule isMeta isExported importAll : Bool),
sizeOf
{ imports := imports, pos := pos, badModifier := badModifier, error? := error?, isModule := isModule,
isMeta := isMeta, isExported := isExported, i... | null | true |
IsDedekindDomain.HeightOneSpectrum.valuationSubringAtPrime_le_valuation | Mathlib.RingTheory.DedekindDomain.AdicValuation | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDedekindDomain R] {K : Type u_2} [inst_2 : Field K]
[inst_3 : Algebra R K] [inst_4 : IsFractionRing R K] (v : IsDedekindDomain.HeightOneSpectrum R),
IsDedekindDomain.HeightOneSpectrum.valuationSubringAtPrime K v ≤
(IsDedekindDomain.HeightOneSpectrum.valuation K v... | null | true |
Polynomial.SplittingField.instCommRing._proof_22 | Mathlib.FieldTheory.SplittingField.Construction | ∀ {K : Type u_1} [inst : Field K] (f : Polynomial K) (a : f.SplittingField), 0 * a = 0 | null | false |
MvPolynomial.totalDegree_zero_iff_isHomogeneous | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ (σ : Type u_1) {R : Type u_3} [inst : CommSemiring R] {p : MvPolynomial σ R}, p.totalDegree = 0 ↔ p.IsHomogeneous 0 | null | true |
Locale.coe_of | Mathlib.Topology.Category.Locale | ∀ (α : Type u_1) [inst : Order.Frame α], ↑(Opposite.unop ↧α) = α | null | true |
CategoryTheory.Limits.IsInitial.uniqueUpToIso._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {T T' : C} (hT : CategoryTheory.Limits.IsInitial T)
(hT' : CategoryTheory.Limits.IsInitial T'),
CategoryTheory.CategoryStruct.comp (hT.to T') (hT'.to T) = CategoryTheory.CategoryStruct.id T | null | false |
Lean.Language.DynamicSnapshot.ctorIdx | Lean.Language.Basic | Lean.Language.DynamicSnapshot → ℕ | null | false |
instFieldGaloisField._aux_59 | Mathlib.FieldTheory.Finite.GaloisField | (p : ℕ) → [inst : Fact (Nat.Prime p)] → (n : ℕ) → ℚ≥0 → GaloisField p n | null | false |
ProjectiveSpectrum.zeroLocus_mul_homogeneousIdeal | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.Topology | ∀ {A : Type u_1} {σ : Type u_2} [inst : CommRing A] [inst_1 : SetLike σ A] [inst_2 : AddSubmonoidClass σ A] (𝒜 : ℕ → σ)
[inst_3 : GradedRing 𝒜] (I J : HomogeneousIdeal 𝒜),
ProjectiveSpectrum.zeroLocus 𝒜 ↑(I * J) = ProjectiveSpectrum.zeroLocus 𝒜 ↑I ∪ ProjectiveSpectrum.zeroLocus 𝒜 ↑J | null | true |
Homeomorph.quotientBot | Mathlib.Topology.Homeomorph.Quotient | {X : Type u_1} → [inst : TopologicalSpace X] → Quotient ⊥ ≃ₜ X | The quotient by the trivial relation is homeomorphic to the original space. | true |
CategoryTheory.Abelian.PreservesCoimage.iso_hom_π | Mathlib.CategoryTheory.Limits.Preserves.Shapes.AbelianImages | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{D : Type u₂} [inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) [inst_4 : F.PreservesZeroMorphisms] {X Y : C} (f : X ⟶ Y)
... | null | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.cycleBypass.match_1.eq_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} {G : SimpleGraph V} {v : V} (motive : G.Walk v v → Sort u_2) (h_1 : Unit → motive SimpleGraph.Walk.nil)
(h_2 : (v_1 : V) → (hvv' : G.Adj v v_1) → (w : G.Walk v_1 v) → motive (SimpleGraph.Walk.cons hvv' w)),
(match SimpleGraph.Walk.nil with
| SimpleGraph.Walk.nil => h_1 ()
| SimpleGraph.Walk... | null | true |
NonUnitalStarAlgHom.rangeRestrict | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u} →
{A : Type v} →
{B : Type w} →
[inst : CommSemiring R] →
[inst_1 : NonUnitalNonAssocSemiring A] →
[inst_2 : Module R A] →
[inst_3 : Star A] →
[inst_4 : NonUnitalNonAssocSemiring B] →
[inst_5 : Module R B] → [inst_6 : Star B] → (f : A ... | Restrict the codomain of a non-unital star algebra homomorphism `f` to `f.range`.
This is the bundled version of `Set.rangeFactorization`. | true |
act_rel_act_of_rel_of_rel | Mathlib.Algebra.Order.Monoid.Unbundled.Defs | ∀ {N : Type u_2} {r : N → N → Prop} {mu : N → N → N} [IsTrans N r] [i : CovariantClass N N mu r]
[i' : CovariantClass N N (Function.swap mu) r] {a b c d : N}, r a b → r c d → r (mu a c) (mu b d) | null | true |
CategoryTheory.ObjectProperty.small_unop_iff._simp_1 | Mathlib.CategoryTheory.ObjectProperty.Small | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty Cᵒᵖ),
CategoryTheory.ObjectProperty.Small.{w, v, u} P.unop = CategoryTheory.ObjectProperty.Small.{w, v, u} P | null | false |
_private.Mathlib.Algebra.Polynomial.Roots.0.Polynomial.nthRoots_two_eq_zero_iff._simp_1_4 | Mathlib.Algebra.Polynomial.Roots | ∀ {α : Sort u_1} {p : α → Prop}, (∀ (x : α), ¬p x) = ¬∃ x, p x | null | false |
BigOperators.delabFinsetSum | Mathlib.Algebra.BigOperators.Group.Finset.Defs | Lean.PrettyPrinter.Delaborator.Delab | Delaborator for `Finset.sum`. The `pp.funBinderTypes` option controls whether
to show the domain type when the sum is over `Finset.univ`. | true |
csSup_inter_le'._auto_3 | Mathlib.Order.ConditionallyCompleteLattice.Basic | Lean.Syntax | null | false |
_private.Mathlib.Order.Preorder.Finite.0.OrderHom.eq_id_of_injective._simp_1_1 | Mathlib.Order.Preorder.Finite | ∀ {α : Type u_1} {ι : Sort u_4} {f : ι → α}, (Set.range f = Set.univ) = Function.Surjective f | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.