name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.Category.Grp.LeftExactFunctor.0.AddCommGrpCat.leftExactFunctorForgetEquivalence.instBraidedCategory | Mathlib.Algebra.Category.Grp.LeftExactFunctor | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Preadditive C] →
[inst_2 : CategoryTheory.Limits.HasFiniteBiproducts C] → CategoryTheory.BraidedCategory C | null | true |
_private.Init.Data.Range.Polymorphic.NatLemmas.0.Nat.getElem!_toArray_rcc_eq_zero_iff._simp_1_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n i : ℕ}, ((m...n).toArray[i]! = 0) = (n ≤ i + m ∨ m = 0 ∧ i = 0) | null | false |
Mathlib.Tactic.Sat.buildReify.reifyClause1 | Mathlib.Tactic.Sat.FromLRAT | ℕ → Lean.Expr → Lean.Expr × Lean.Expr | Returns `a` and `pr : reify v c a` given a nonempty clause `c` | true |
ProfiniteGrp.profiniteCompletion._proof_4 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Completion | ∀ {X Y Z : GrpCat} (f : X ⟶ Y) (g : Y ⟶ Z),
ProfiniteGrp.ProfiniteCompletion.lift
(CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g)
(ProfiniteGrp.ProfiniteCompletion.eta Z)) =
CategoryTheory.CategoryStruct.comp
(ProfiniteGrp.ProfiniteCompletion.lift
(Category... | null | false |
RootPairing.rootForm_self_eq_zero_iff | Mathlib.LinearAlgebra.RootSystem.Finite.Nondegenerate | ∀ {ι : Type u_1} {R : Type u_2} {M : Type u_3} {N : Type u_4} [inst : Fintype ι] [inst_1 : AddCommGroup M]
[inst_2 : AddCommGroup N] [inst_3 : CommRing R] [inst_4 : LinearOrder R] [IsStrictOrderedRing R] [inst_6 : Module R M]
[inst_7 : Module R N] (P : RootPairing ι R M N) {x : M}, (P.RootForm x) x = 0 ↔ x ∈ Linear... | null | true |
Std.Time.instHAddOffsetOffset_41 | Std.Time.Date.Basic | HAdd Std.Time.Week.Offset Std.Time.Day.Offset Std.Time.Day.Offset | null | true |
AddConjClasses.instDecidableEqOfDecidableRelIsAddConj | Mathlib.Algebra.Group.Conj | {α : Type u} → [inst : AddMonoid α] → [DecidableRel IsAddConj] → DecidableEq (AddConjClasses α) | null | true |
Lean.IR.Sorry.State.noConfusionType | Lean.Compiler.IR.Sorry | Sort u → Lean.IR.Sorry.State → Lean.IR.Sorry.State → Sort u | null | false |
PreAbstractSimplicialComplex.instInfSet.match_1 | Mathlib.AlgebraicTopology.SimplicialComplex.Basic | ∀ (ι : Type u_1) (s : Set (PreAbstractSimplicialComplex ι)) {x : Finset ι}
(motive : x ∈ (⋂ K ∈ s, K.faces) ∩ {t | t.Nonempty} → Prop) (x_1 : x ∈ (⋂ K ∈ s, K.faces) ∩ {t | t.Nonempty}),
(∀ (hx : x ∈ ⋂ K ∈ s, K.faces) (hn : x ∈ {t | t.Nonempty}), motive ⋯) → motive x_1 | null | false |
_private.Std.Async.Basic.0.Std.Async.EAsync.forIn.loop._unsafe_rec | Std.Async.Basic | {ε β : Type} → (Unit → β → Std.Async.EAsync ε (ForInStep β)) → Task.Priority → IO.Promise (Except ε β) → β → BaseIO Unit | null | false |
Lean.Widget.PanelWidgetsExtEntry._sizeOf_1 | Lean.Widget.UserWidget | Lean.Widget.PanelWidgetsExtEntry → ℕ | null | false |
_private.Mathlib.Tactic.TacticAnalysis.Declarations.0.initFn._@.Mathlib.Tactic.TacticAnalysis.Declarations.1209483221._hygCtx._hyg.4 | Mathlib.Tactic.TacticAnalysis.Declarations | IO (Lean.Option Bool) | null | false |
_private.Mathlib.LinearAlgebra.Dual.Lemmas.0.Module.instIsReflexiveOfFiniteOfProjective.match_1 | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ (R : Type u_2) (N : Type u_1) [inst : CommSemiring R] [inst_1 : AddCommMonoid N] [inst_2 : Module R N] (w : ℕ)
(f : (Fin w → R) →ₗ[R] N) (motive : (∃ h, f ∘ₗ h = LinearMap.id) → Prop) (x : ∃ h, f ∘ₗ h = LinearMap.id),
(∀ (g : N →ₗ[R] Fin w → R) (H : f ∘ₗ g = LinearMap.id), motive ⋯) → motive x | null | false |
Shrink.instIsRightCancelAdd | Mathlib.Algebra.Group.Shrink | ∀ {α : Type u_2} [inst : Small.{v, u_2} α] [inst_1 : Add α] [IsRightCancelAdd α], IsRightCancelAdd (Shrink.{v, u_2} α) | null | true |
Lean.Expr.FoldConstsImpl.State.noConfusion | Lean.Util.FoldConsts | {P : Sort u} → {t t' : Lean.Expr.FoldConstsImpl.State} → t = t' → Lean.Expr.FoldConstsImpl.State.noConfusionType P t t' | null | false |
Lean.Meta.Grind.AC.DiseqCnstrProof.brecOn.eq | Lean.Meta.Tactic.Grind.AC.Types | ∀ {motive_1 : Lean.Meta.Grind.AC.DiseqCnstr → Sort u} {motive_2 : Lean.Meta.Grind.AC.DiseqCnstrProof → Sort u}
(t : Lean.Meta.Grind.AC.DiseqCnstrProof) (F_1 : (t : Lean.Meta.Grind.AC.DiseqCnstr) → t.below → motive_1 t)
(F_2 : (t : Lean.Meta.Grind.AC.DiseqCnstrProof) → t.below → motive_2 t),
t.brecOn F_1 F_2 = F_2... | null | true |
Array.PrefixTable.noConfusionType | Batteries.Data.Array.Match | Sort u → {α : Type u_1} → Array.PrefixTable α → {α' : Type u_1} → Array.PrefixTable α' → Sort u | null | false |
Lean.Compiler.LCNF.SimpleGroundExpr._sizeOf_1 | Lean.Compiler.LCNF.SimpleGroundExpr | Lean.Compiler.LCNF.SimpleGroundExpr → ℕ | null | false |
CochainComplex.homologyMap_exact₂_of_distTriang | Mathlib.Algebra.Homology.DerivedCategory.HomologySequence | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : HasDerivedCategory C] (T : CategoryTheory.Pretriangulated.Triangle (CochainComplex C ℤ))
(hT : DerivedCategory.Q.mapTriangle.obj T ∈ CategoryTheory.Pretriangulated.distinguishedTriangles) (n : ℤ),
{ X₁ := Homolo... | null | true |
Filter.IsCountablyGenerated.casesOn | Mathlib.Order.Filter.CountablyGenerated | {α : Type u_1} →
{f : Filter α} →
{motive : f.IsCountablyGenerated → Sort u} →
(t : f.IsCountablyGenerated) → ((out : ∃ s, s.Countable ∧ f = Filter.generate s) → motive ⋯) → motive t | null | false |
MeasureTheory.measureReal_prod_prod | Mathlib.MeasureTheory.Measure.Prod | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] {μ : MeasureTheory.Measure α}
{ν : MeasureTheory.Measure β} [hν : MeasureTheory.SFinite ν] (s : Set α) (t : Set β),
(μ.prod ν).real (s ×ˢ t) = μ.real s * ν.real t | null | true |
SFinKer.tensorHom_def | Mathlib.Probability.Kernel.Category.SFinKer | ∀ {X₁ Y₁ X₂ Y₂ : SFinKer} (f : X₁ ⟶ Y₁) (g : X₂ ⟶ Y₂),
CategoryTheory.MonoidalCategoryStruct.tensorHom f g =
CategoryTheory.CategoryStruct.comp
((fun {X₁ X₂} κ Y => { hom := κ.hom.parallelComp ProbabilityTheory.Kernel.id, property := ⋯ }) f X₂)
((fun X Y₁ Y₂ κ => { hom := ProbabilityTheory.Kernel.id.p... | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.go._proof_21 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | ∀ (w n : ℕ) (aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (lhs : aig.RefVec w)
(aig_1 : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) (rhs : aig_1.RefVec n)
(hraig : aig.decls.size ≤ { aig := aig_1, vec := rhs }.aig.decls.size),
(↑⟨{ aig := aig_1, vec := rhs }, hraig⟩).aig.decls.size ≤
(Std.Tactic.BVDecide.BVExpr.bi... | null | false |
RingHom.star_def | Mathlib.Algebra.Star.Basic | ∀ {R : Type u} [inst : CommSemiring R] [inst_1 : StarRing R] {S : Type u_1} [inst_2 : NonAssocSemiring S] (f : S →+* R),
star f = (starRingEnd R).comp f | null | true |
BitVec.toNat_umod | Init.Data.BitVec.Lemmas | ∀ {n : ℕ} {x y : BitVec n}, (x % y).toNat = x.toNat % y.toNat | null | true |
CategoryTheory.objUp_objDown | Mathlib.CategoryTheory.Category.ULift | ∀ {C : Type u_1} (A : CategoryTheory.ULiftHom C), CategoryTheory.ULiftHom.objUp A.objDown = A | null | true |
ZNum.cast_bit1 | Mathlib.Data.Num.ZNum | ∀ {α : Type u_1} [inst : AddGroupWithOne α] (n : ZNum), ↑n.bit1 = ↑n + ↑n + 1 | null | true |
Zsqrtd.linearOrder._proof_5 | Mathlib.NumberTheory.Zsqrtd.Basic | ∀ {d : ℕ} (a b : ℤ√↑d), compareOfLessAndEq a b = compareOfLessAndEq a b | null | false |
eventually_norm_pow_le | Mathlib.Analysis.Normed.Ring.Basic | ∀ {α : Type u_2} [inst : SeminormedRing α] (a : α), ∀ᶠ (n : ℕ) in Filter.atTop, ‖a ^ n‖ ≤ ‖a‖ ^ n | null | true |
_private.Lean.Meta.LetToHave.0.Lean.Meta.LetToHave.ensureType.match_1 | Lean.Meta.LetToHave | (motive : Lean.Expr → Sort u_1) →
(__x : Lean.Expr) → ((u : Lean.Level) → motive (Lean.Expr.sort u)) → ((x : Lean.Expr) → motive x) → motive __x | null | false |
IsAddTorsion.of_surjective | Mathlib.GroupTheory.Torsion | ∀ {G : Type u_1} {H : Type u_2} [inst : AddGroup G] [inst_1 : AddGroup H] {f : G →+ H},
Function.Surjective ⇑f → IsAddTorsion G → IsAddTorsion H | The image of a surjective torsion additive group homomorphism is torsion. | true |
Lean.JsonRpc.MessageKind.noConfusion | Lean.Data.JsonRpc | {P : Sort v✝} → {x y : Lean.JsonRpc.MessageKind} → x = y → Lean.JsonRpc.MessageKind.noConfusionType P x y | null | false |
TopCat.isEmbedding_of_pullback | Mathlib.Topology.Category.TopCat.Limits.Pullbacks | ∀ {X Y S : TopCat} {f : X ⟶ S} {g : Y ⟶ S},
Topology.IsEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f) →
Topology.IsEmbedding ⇑(CategoryTheory.ConcreteCategory.hom g) →
Topology.IsEmbedding
⇑(CategoryTheory.ConcreteCategory.hom
(CategoryTheory.Limits.limit.π (CategoryTheory.Limits.cos... | null | true |
Function.Injective.isCancelAdd | Mathlib.Algebra.Group.InjSurj | ∀ {M₁ : Type u_1} {M₂ : Type u_2} [inst : Add M₁] [inst_1 : Add M₂] [IsCancelAdd M₂] (f : M₁ → M₂),
Function.Injective f → (∀ (x y : M₁), f (x + y) = f x + f y) → IsCancelAdd M₁ | A type has cancellative addition, if it admits an injective map that
preserves `+` to another type with cancellative addition. | true |
Orientation.inner_eq_zero_iff_eq_zero_or_eq_smul_rotation_pi_div_two | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) {x y : V}, inner ℝ x y = 0 ↔ x = 0 ∨ ∃ r, r • (o.rotation ↑(Real.pi / 2)) x = y | The inner product between two vectors is zero if and only if the first vector is zero or
the second is a multiple of a `π / 2` rotation of that vector. | true |
_aux_Init_NotationExtra___macroRules_tacticFunext____1 | Init.NotationExtra | Lean.Macro | null | false |
DividedPowers.SubDPIdeal.instBot._proof_1 | Mathlib.RingTheory.DividedPowers.SubDPIdeal | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} {hI : DividedPowers I} (x : ℕ),
x ≠ 0 → ∀ x_1 ∈ ⊥, hI.dpow x x_1 ∈ ⊥ | null | false |
HasFDerivAt.sqrt | Mathlib.Analysis.SpecialFunctions.Sqrt | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {f : E → ℝ} {x : E} {f' : StrongDual ℝ E},
HasFDerivAt f f' x → f x ≠ 0 → HasFDerivAt (fun y => √(f y)) ((1 / (2 * √(f x))) • f') x | null | true |
CategoryTheory.Cat.HasLimits.homDiagram_map | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type v} [inst : CategoryTheory.SmallCategory J] {F : CategoryTheory.Functor J CategoryTheory.Cat}
(X Y : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)) {X_1 Y_1 : J} (f : X_1 ⟶ Y_1),
(CategoryTheory.Cat.HasLimits.homDiagram X Y).map f =
TypeCat.ofHom fun g =>
CategoryTheory.Catego... | null | true |
CategoryTheory.StrictlyUnitaryLaxFunctor.mapIdIso_inv | Mathlib.CategoryTheory.Bicategory.Functor.StrictlyUnitary | ∀ {B : Type u₁} [inst : CategoryTheory.Bicategory B] {C : Type u₂} [inst_1 : CategoryTheory.Bicategory C]
(F : CategoryTheory.StrictlyUnitaryLaxFunctor B C) (x : B), (F.mapIdIso x).inv = CategoryTheory.eqToHom ⋯ | null | true |
UniqueFactorizationMonoid.multiplicative_prime_power | Mathlib.RingTheory.UniqueFactorizationDomain.Multiplicative | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [UniqueFactorizationMonoid α] {β : Type u_2}
[inst_2 : CommMonoidWithZero β] {f : α → β} (s : Finset α) (i j : α → ℕ),
(∀ p ∈ s, Prime p) →
(∀ p ∈ s, ∀ q ∈ s, p ∣ q → p = q) →
(∀ {x y : α}, IsUnit y → f (x * y) = f x * f y) →
(∀ {p : α} (i : ℕ), Prime... | If `f` maps `p ^ i` to `(f p) ^ i` for primes `p`, and `f`
is multiplicative on coprime elements, then `f` is multiplicative on all products of primes. | true |
_private.Mathlib.Analysis.SpecialFunctions.Gamma.Basic.0.Complex.GammaAux._sunfold | Mathlib.Analysis.SpecialFunctions.Gamma.Basic | ℕ → ℂ → ℂ | null | false |
CategoryTheory.Limits.weightedLimObjCoyonedaObjIso._proof_3 | Mathlib.CategoryTheory.Limits.Weighted.HasWeightedLimit | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} C] (j : J) (F : CategoryTheory.Functor J C),
CategoryTheory.Limits.HasWeightedLimit (CategoryTheory.coyoneda.obj (Opposite.op j)) F | null | false |
Subalgebra.map_le | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : Semiring B] [inst_4 : Algebra R B] {S : Subalgebra R A} {f : A →ₐ[R] B} {U : Subalgebra R B},
Subalgebra.map f S ≤ U ↔ S ≤ Subalgebra.comap f U | null | true |
DirectLimit.instDistribSMulOfMulActionHomClass._proof_1 | Mathlib.Algebra.Colimit.DirectLimit | ∀ {R : Type u_4} {ι : Type u_1} [inst : Preorder ι] {G : ι → Type u_2} {T : ⦃i j : ι⦄ → i ≤ j → Type u_3}
{f : (x x_1 : ι) → (h : x ≤ x_1) → T h} [inst_1 : (i j : ι) → (h : i ≤ j) → FunLike (T h) (G i) (G j)]
[inst_2 : DirectedSystem G fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] [inst_4 : Nonempty ι... | null | false |
IsCompactlyGenerated.BooleanGenerators.mk | Mathlib.Order.BooleanGenerators | ∀ {α : Type u_1} [inst : CompleteLattice α] {S : Set α},
(∀ I ∈ S, IsAtom I) →
(∀ (s : Finset α) (a : α), ↑s ⊆ S → IsCompactElement a → a ≤ s.sup id → ∃ t ⊆ s, a = t.sup id) →
IsCompactlyGenerated.BooleanGenerators S | null | true |
HolorIndex.cast_type | Mathlib.Data.Holor | ∀ {ds₁ ds₂ : List ℕ} (is : List ℕ) (eq : ds₁ = ds₂) (h : List.Forall₂ (fun x1 x2 => x1 < x2) is ds₁),
↑(cast ⋯ ⟨is, h⟩) = is | null | true |
IsTopologicalRing.toIsTopologicalSemiring | Mathlib.Topology.Algebra.Ring.Basic | ∀ {R : Type u_1} {inst : TopologicalSpace R} {inst_1 : NonUnitalNonAssocRing R} [self : IsTopologicalRing R],
IsTopologicalSemiring R | null | true |
Aesop.Stats._sizeOf_inst | Aesop.Stats.Basic | SizeOf Aesop.Stats | null | false |
Turing.TM1to1.tr | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} →
{Λ : Type u_2} →
{σ : Type u_3} →
{n : ℕ} →
(Γ → List.Vector Bool n) →
(List.Vector Bool n → Γ) →
(Λ → Turing.TM1.Stmt Γ Λ σ) → Turing.TM1to1.Λ' Γ Λ σ → Turing.TM1.Stmt Bool (Turing.TM1to1.Λ' Γ Λ σ) σ | The top level program. | true |
ZMod.instIsAddCyclic | Mathlib.GroupTheory.SpecificGroups.Cyclic | ∀ (n : ℕ), IsAddCyclic (ZMod n) | null | true |
AlgebraicGeometry.tilde.adjunction._proof_1 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : ModuleCat ↑R),
CategoryTheory.CategoryStruct.comp
((AlgebraicGeometry.tilde.functor R).map (AlgebraicGeometry.tilde.toTildeΓNatIso.hom.app M))
(AlgebraicGeometry.Scheme.Modules.fromTildeΓNatTrans.app ((AlgebraicGeometry.tilde.functor R).obj M)) =
CategoryTheory.CategoryStruct.... | null | false |
_private.Qq.Match.0.Qq._aux_Qq_Match___macroRules_Lean_Parser_Term_match_1.match_3 | Qq.Match | (motive : Option (Array (Lean.TSyntax `term)) → Sort u_1) →
(x : Option (Array (Lean.TSyntax `term))) →
((patss : Array (Lean.TSyntax `term)) → motive (some patss)) → (Unit → motive none) → motive x | null | false |
Affine.Simplex.excenter | Mathlib.Geometry.Euclidean.Incenter.Basic | {V : Type u_1} →
{P : Type u_2} →
[inst : NormedAddCommGroup V] →
[inst_1 : InnerProductSpace ℝ V] →
[inst_2 : MetricSpace P] →
[inst_3 : NormedAddTorsor V P] → {n : ℕ} → [NeZero n] → Affine.Simplex ℝ P n → Finset (Fin (n + 1)) → P | The excenter with signs determined by the given set of indices (for the empty set, this is
the incenter; for a singleton set, this is the excenter opposite a vertex). This is only
meaningful if `s.ExcenterExists signs`; otherwise, it is some arbitrary point. | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.Ordered.find?_some.match_1_3 | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cut : α → Ordering} {t : RBTree.RBNode α} (motive : (∃ x, RBTree.RBNode.find? cut t = some x) → Prop)
(x : ∃ x, RBTree.RBNode.find? cut t = some x),
(∀ (y : α) (hy : RBTree.RBNode.find? cut t = some y), motive ⋯) → motive x | null | false |
_private.Mathlib.Data.Nat.Log.0.Nat.clog_of_one_lt._proof_1_4 | Mathlib.Data.Nat.Log | ∀ {b n : ℕ}, 1 < b → ∀ (c : ℕ), n ≤ b ^ c * b ↔ n + b - 1 ≤ b ^ c * b + b - 1 | null | false |
_private.Mathlib.Analysis.Asymptotics.Ring.0.Asymptotics.IsBigOWith.inv_rev._simp_1_2 | Mathlib.Analysis.Asymptotics.Ring | ∀ {α : Type u_1} [inst : DivisionCommMonoid α] (a b : α), b⁻¹ * a = a / b | null | false |
Int64.decEq._proof_2 | Init.Data.SInt.Basic | ∀ (n m : UInt64), ¬n = m → { toUInt64 := n } = { toUInt64 := m } → False | null | false |
_private.Lean.Meta.Match.Basic.0.Lean.Meta.Match.Pattern.toExpr.visit | Lean.Meta.Match.Basic | Bool → Lean.Meta.Match.Pattern → Lean.MetaM Lean.Expr | null | true |
CategoryTheory.NatIso.mapHomologicalComplex._proof_2 | Mathlib.Algebra.Homology.Additive | ∀ {ι : Type u_1} {W₁ : Type u_2} {W₂ : Type u_5} [inst : CategoryTheory.Category.{u_3, u_2} W₁]
[inst_1 : CategoryTheory.Category.{u_4, u_5} W₂] [inst_2 : CategoryTheory.Limits.HasZeroMorphisms W₁]
[inst_3 : CategoryTheory.Limits.HasZeroMorphisms W₂] {F G : CategoryTheory.Functor W₁ W₂}
[inst_4 : F.PreservesZeroM... | null | false |
Lean.Widget.PanelWidgetInstance.mk.inj | Lean.Widget.UserWidget | ∀ {toWidgetInstance : Lean.Widget.WidgetInstance} {range? : Option Lean.Lsp.Range} {name? : Option String}
{toWidgetInstance_1 : Lean.Widget.WidgetInstance} {range?_1 : Option Lean.Lsp.Range} {name?_1 : Option String},
{ toWidgetInstance := toWidgetInstance, range? := range?, name? := name? } =
{ toWidgetInst... | null | true |
LinearEquiv.instZero._proof_1 | Mathlib.Algebra.Module.Equiv.Basic | ∀ {R : Type u_3} {R₂ : Type u_4} {M : Type u_2} {M₂ : Type u_1} [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₂}
(x y : M), (LinearMap.toAddHom 0).toFun (x + y) = (LinearMap.toAddHom 0).toFun x + (LinearM... | null | false |
CategoryTheory.Abelian.SpectralObject.descOpcycles.congr_simp | Mathlib.Algebra.Homology.SpectralObject.Cycles | ∀ {C : Type u_1} {ι : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k : ι} (f : i ⟶ j) (g : j ⟶ k) (n₀ n₀_1 : ℤ) (e_n₀ : n₀ = n₀_1)
(n₁ : ℤ) (hn₁ : n₀ + 1 = n₁) {A : C... | null | true |
Lean.Grind.Ring.OfSemiring.r_trans | Init.Grind.Ring.Envelope | ∀ {α : Type u} [inst : Lean.Grind.Semiring α] {a b c : α × α},
Lean.Grind.Ring.OfSemiring.r α a b → Lean.Grind.Ring.OfSemiring.r α b c → Lean.Grind.Ring.OfSemiring.r α a c | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Adjoint.0.ContinuousLinearMap.adjointAux._proof_8 | Mathlib.Analysis.InnerProductSpace.Adjoint | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E],
IsTopologicalAddGroup (E →L[𝕜] 𝕜) | null | false |
cfcₙ_le_iff._auto_5 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.NonUnital | Lean.Syntax | null | false |
LinearMap.BilinForm.IsometryEquiv.toIsometry._proof_2 | Mathlib.LinearAlgebra.BilinearForm.IsometryEquiv | ∀ {R : Type u_3} {M₁ : Type u_2} {M₂ : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : Module R M₁] [inst_4 : Module R M₂] {B₁ : LinearMap.BilinForm R M₁}
{B₂ : LinearMap.BilinForm R M₂} (g : B₁.IsometryEquiv B₂) (m : R) (x : M₁),
(↑g.toLinearEquiv).toFun (m • x... | null | false |
_private.Mathlib.RingTheory.Localization.Away.Basic.0.IsLocalization.Away.map_surjective_iff._simp_1_4 | Mathlib.RingTheory.Localization.Away.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | null | false |
_private.Std.Data.Iterators.Lemmas.Combinators.Zip.0.Std.Iter.atIdxSlow?_eq_match.match_1.eq_2 | Std.Data.Iterators.Lemmas.Combinators.Zip | ∀ (motive : ℕ → Sort u_1) (n : ℕ) (h_1 : Unit → motive 0) (h_2 : (n : ℕ) → motive n.succ),
(match n.succ with
| 0 => h_1 ()
| n.succ => h_2 n) =
h_2 n | null | true |
RightCancelSemigroup.casesOn | Mathlib.Algebra.Group.Semigroup | {G : Type u_2} →
{motive : RightCancelSemigroup G → Sort u} →
(t : RightCancelSemigroup G) →
([toSemigroup : Semigroup G] →
[toIsRightCancelMul : IsRightCancelMul G] →
motive { toSemigroup := toSemigroup, toIsRightCancelMul := toIsRightCancelMul }) →
motive t | null | false |
Lean.Elab.SyntaxDeprecationEntry._sizeOf_inst | Lean.Elab.DeprecatedSyntax | SizeOf Lean.Elab.SyntaxDeprecationEntry | null | false |
Lean.Lsp.RefIdent.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.RefIdent → Sort u} →
(t : Lean.Lsp.RefIdent) →
((moduleName identName : String) → motive (Lean.Lsp.RefIdent.const moduleName identName)) →
((moduleName id : String) → motive (Lean.Lsp.RefIdent.fvar moduleName id)) → motive t | null | false |
abs_mul_self | Mathlib.Algebra.Order.Ring.Abs | ∀ {α : Type u_1} [inst : Ring α] [inst_1 : LinearOrder α] [IsOrderedRing α] (a : α), |a * a| = a * a | null | true |
CategoryTheory.MorphismProperty.IsInvertedBy.iff_of_iso | Mathlib.CategoryTheory.MorphismProperty.IsInvertedBy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u'} [inst_1 : CategoryTheory.Category.{v', u'} D]
(W : CategoryTheory.MorphismProperty C) {F₁ F₂ : CategoryTheory.Functor C D} (e : F₁ ≅ F₂),
W.IsInvertedBy F₁ ↔ W.IsInvertedBy F₂ | null | true |
instRingFreeRing._aux_36 | Mathlib.RingTheory.FreeRing | (α : Type u_1) → ℤ → FreeRing α → FreeRing α | null | false |
Finset.card_le_card_mul_self | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : Mul α] [IsLeftCancelMul α] [inst_2 : DecidableEq α] {s : Finset α}, s.card ≤ (s * s).card | The size of `s * s` is at least the size of `s`, version with left-cancellative multiplication.
See `card_le_card_mul_self'` for the version with right-cancellative multiplication.
| true |
Lean.Grind.CommRing.Expr.denoteS_toPolyS | Init.Grind.Ring.CommSemiringAdapter | ∀ {α : Type u_1} [inst : Lean.Grind.CommSemiring α] (ctx : Lean.Grind.CommRing.Context α)
(e : Lean.Grind.CommRing.Expr),
Lean.Grind.CommRing.Poly.denoteS ctx e.toPolyS = Lean.Grind.CommRing.Expr.denoteS ctx e | null | true |
CochainComplex.HomComplex.Cochain.single_v_eq_zero | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ L.X q) (n p' q' : ℤ) (hpq' : p' + n = q'),
p' ≠ p → (CochainComplex.HomComplex.Cochain.single f n).v p' q' hpq' = 0 | null | true |
AbsoluteValue.IsAdmissible.mk | Mathlib.NumberTheory.ClassNumber.AdmissibleAbsoluteValue | {R : Type u_1} →
[inst : EuclideanDomain R] →
{abv : AbsoluteValue R ℤ} →
abv.IsEuclidean →
(card : ℝ → ℕ) →
(∀ (n : ℕ) {ε : ℝ},
0 < ε →
∀ {b : R},
b ≠ 0 →
∀ (A : Fin n → R), ∃ t, ∀ (i₀ i₁ : Fin n), t i₀ = t i₁ → ↑(abv (A ... | null | true |
RBTree.RBNode.Path.ins._f | Batteries.Recycling.RBTree.Basic | {α : Type u_1} →
(x : RBTree.RBNode.Path α) →
RBTree.RBNode.Path.below (motive := fun x => RBTree.RBNode α → RBTree.RBNode α) x →
RBTree.RBNode α → RBTree.RBNode α | null | false |
Std.Time.Nanosecond.Ordinal.instTransOrdOfDay | Std.Time.Time.Unit.Nanosecond | Std.TransOrd Std.Time.Nanosecond.Ordinal.OfDay | null | true |
ZFClass.«term⋂₀_» | Mathlib.SetTheory.ZFC.Class | Lean.ParserDescr | The intersection of a class is the class of all members of ZFC sets in the class .
Uses `⋂₀` notation, scoped under the `ZFClass` namespace. | true |
CategoryTheory.ComposableArrows.Precomp.obj_one | Mathlib.CategoryTheory.ComposableArrows.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {n : ℕ} (F : CategoryTheory.ComposableArrows C n)
(X : C), CategoryTheory.ComposableArrows.Precomp.obj F X 1 = F.obj' 0 ⋯ | null | true |
RingCat.Colimits.ColimitType.AddGroupWithOne | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
(F : CategoryTheory.Functor J RingCat) → AddGroupWithOne (RingCat.Colimits.ColimitType F) | null | true |
TopologicalSpace.IrreducibleCloseds.mk_singleton | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] [inst_1 : T1Space α] {x : α},
{ carrier := {x}, isIrreducible' := ⋯, isClosed' := ⋯ } = {x} | null | true |
CategoryTheory.Limits.pushout.instIsSplitMonoInl | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] {X Y : C} (f : X ⟶ Y)
[inst_1 : CategoryTheory.Limits.HasPushout f f], CategoryTheory.IsSplitMono (CategoryTheory.Limits.pushout.inl f f) | null | true |
Order.Ideal.sup_mem | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : SemilatticeSup P] {x y : P} {s : Order.Ideal P}, x ∈ s → y ∈ s → x ⊔ y ∈ s | A specific witness of `I.directed` when `P` has joins. | true |
mem_algebraicClosure_iff | Mathlib.FieldTheory.AlgebraicClosure | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
x ∈ algebraicClosure F E ↔ IsAlgebraic F x | An element is contained in the algebraic closure of `F` in `E` if and only if
it is an algebraic element. | true |
ModuleCat.injectiveDimension_le_injectiveDimension_of_isLocalizedModule | Mathlib.RingTheory.LocalProperties.InjectiveDimension | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Small.{v, u} R] [IsNoetherianRing R] (S : Submonoid R) (M : ModuleCat R),
CategoryTheory.injectiveDimension (M.localizedModule S) ≤ CategoryTheory.injectiveDimension M | null | true |
Finset.expect_neg_distrib | Mathlib.Algebra.BigOperators.Expect | ∀ {ι : Type u_1} {M : Type u_4} [inst : AddCommGroup M] [inst_1 : Module ℚ≥0 M] (s : Finset ι) (f : ι → M),
(s.expect fun i => -f i) = -s.expect fun i => f i | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0.Int8.reduceMul._regBuiltin.Int8.reduceMul.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2990342300._hygCtx._hyg.89 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
_private.Mathlib.Data.Set.NAry.0.Set.Nonempty.image2.match_1_1 | Mathlib.Data.Set.NAry | ∀ {β : Type u_1} {t : Set β} (motive : t.Nonempty → Prop) (x : t.Nonempty),
(∀ (w : β) (hb : w ∈ t), motive ⋯) → motive x | null | false |
List.signVariations_filter_ne_zero | Mathlib.Data.List.SignVariations | ∀ {α : Type u_1} [inst : Zero α] [inst_1 : LinearOrder α] (l : List α),
(List.filter (fun x => !decide (x = 0)) l).signVariations = l.signVariations | Zero entries do not contribute to the sign variations. | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getD_union._simp_1_1 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {x : Ord α} {x_1 : BEq α} [Std.LawfulBEqOrd α] {a b : α}, (compare a b = Ordering.eq) = ((a == b) = true) | null | false |
Finset.val_toFinset | Mathlib.Data.Finset.Dedup | ∀ {α : Type u_1} [inst : DecidableEq α] (s : Finset α), s.val.toFinset = s | null | true |
CategoryTheory.Functor.inr_biprodComparison' | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Biproducts | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
[inst_2 : CategoryTheory.Limits.HasZeroMorphisms C] [inst_3 : CategoryTheory.Limits.HasZeroMorphisms D]
(F : CategoryTheory.Functor C D) (X Y : C) [inst_4 : CategoryTheory.Limits.HasBinaryBiproduc... | null | true |
WithTop.instSemiring._proof_3 | Mathlib.Algebra.Order.Ring.WithTop | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Semiring α] [inst_2 : Subsingleton (AddUnits α)]
[inst_3 : NoZeroDivisors α] (a b c : WithTop α), a * (b + c) = a * b + a * c | null | false |
HomologicalComplex.truncLE'ToRestriction._proof_1 | Mathlib.Algebra.Homology.Embedding.TruncLE | ∀ {ι : Type u_1} {ι' : Type u_2} {c : ComplexShape ι} {c' : ComplexShape ι'} (e : c.Embedding c') [e.IsTruncLE],
e.op.IsRelIff | null | false |
WithLp.toLp.noConfusion | Mathlib.Analysis.Normed.Lp.WithLp | {p : ENNReal} →
{V : Type u_1} → {P : Sort u} → {ofLp ofLp' : V} → WithLp.toLp p ofLp = WithLp.toLp p ofLp' → (ofLp ≍ ofLp' → P) → P | null | false |
Lean.Meta.Grind.NewRawFact.generation | Lean.Meta.Tactic.Grind.Types | Lean.Meta.Grind.NewRawFact → ℕ | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.