name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
Lean.Grind.PowIdentity.pow | Init.Grind.Ring.Basic | ∀ {α : Type u_1} {p : ℕ} [inst : Lean.Grind.CommSemiring α] [Lean.Grind.PowIdentity α p] (x : α), x ^ p = x | null | true |
_private.Mathlib.Combinatorics.Tiling.Tile.0.DiscreteTiling.PlacedTile.instSMul._simp_1 | Mathlib.Combinatorics.Tiling.Tile | ∀ {α : Type u_1} [inst : Group α] {s : Subgroup α} {a b : α}, (↑a = ↑b) = (a⁻¹ * b ∈ s) | null | false |
Subgroup.fg_iff_submonoid_fg | Mathlib.GroupTheory.Finiteness | ∀ {G : Type u_3} [inst : Group G] (P : Subgroup G), P.FG ↔ P.FG | A subgroup is finitely generated if and only if it is finitely generated as a submonoid. | true |
Equiv.completeDistribLattice._proof_12 | Mathlib.Order.CompleteBooleanAlgebra | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : CompleteDistribLattice β] (a b : α),
e (e.symm (e a \ e b)) = e a \ e b | null | false |
Nat.bitwise_of_ne_zero | Mathlib.Data.Nat.Bitwise | ∀ {f : Bool → Bool → Bool} {n m : ℕ},
n ≠ 0 → m ≠ 0 → Nat.bitwise f n m = Nat.bit (f n.bodd m.bodd) (Nat.bitwise f (n / 2) (m / 2)) | null | true |
Std.HashSet.Raw.insertMany | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → {ρ : Type v} → [ForIn Id ρ α] → Std.HashSet.Raw α → ρ → Std.HashSet.Raw α | Inserts multiple mappings into the hash set by iterating over the given collection and calling
`insert`. If the same key appears multiple times, the first occurrence takes precedence.
Note: this precedence behavior is true for `HashSet` and `HashSet.Raw`. The `insertMany` function on
`HashMap`, `DHashMap`, `HashMap.Ra... | true |
CategoryTheory.Bicategory.rightZigzag | Mathlib.CategoryTheory.Bicategory.Adjunction.Basic | {B : Type u₁} →
[inst : CategoryTheory.Bicategory B] →
{a b : B} →
{f : a ⟶ b} →
{g : b ⟶ a} →
(CategoryTheory.CategoryStruct.id a ⟶ CategoryTheory.CategoryStruct.comp f g) →
(CategoryTheory.CategoryStruct.comp g f ⟶ CategoryTheory.CategoryStruct.id b) →
(Category... | The 2-morphism defined by the following pasting diagram:
```
a －－－－－－ ▸ a
◥ ＼ η ◥
g ／ ＼ f ／ g
／ ε ◢ ／
b －－－－－－ ▸ b
```
| true |
AddAction.ofQuotientStabilizer_mk | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (G : Type u) {X : Type v} [inst : AddGroup G] [inst_1 : AddAction G X] (x : X) (g : G),
AddAction.ofQuotientStabilizer G x ↑g = g +ᵥ x | null | true |
Bool.and_comm | Init.Data.Bool | ∀ (x y : Bool), (x && y) = (y && x) | null | true |
Aesop.GoalId.instLT | Aesop.Tree.Data | LT Aesop.GoalId | null | true |
_private.Lean.Elab.Tactic.Basic.0.Lean.Elab.Tactic.getMainGoal.loop._unsafe_rec | Lean.Elab.Tactic.Basic | List Lean.MVarId → Lean.Elab.Tactic.TacticM Lean.MVarId | null | false |
Set.vadd_Icc | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : LinearOrder α] [IsOrderedAddMonoid α] [AddLeftReflectLE α]
[ExistsAddOfLE α] (a b c : α), a +ᵥ Set.Icc b c = Set.Icc (a + b) (a + c) | null | true |
Matrix.ofMeasurableEquiv._proof_1 | Mathlib.Analysis.Matrix.MeasurableSpace | ∀ (m : Type u_1) (n : Type u_2) (α : Type u_3) [inst : MeasurableSpace α], Measurable id | null | false |
Vector.toArray_mk | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Array α} (h : xs.size = n), (Vector.mk xs h).toArray = xs | null | true |
AlgebraicGeometry.Scheme.PartialMap.compHom_id | Mathlib.AlgebraicGeometry.Birational.RationalMap | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X.PartialMap Y), f.compHom (CategoryTheory.CategoryStruct.id Y) = f | null | true |
Lean.Compiler.LCNF.instInhabitedSpecState | Lean.Compiler.LCNF.SpecInfo | Inhabited Lean.Compiler.LCNF.SpecState | null | true |
_private.Lean.Meta.Tactic.Grind.MarkNestedSubsingletons.0.Lean.Meta.Grind.markNestedSubsingletons.visitLambda.loop._unsafe_rec | Lean.Meta.Tactic.Grind.MarkNestedSubsingletons | Lean.Expr → Lean.Expr → optParam (Array Lean.Expr) #[] → optParam Bool false → Lean.Meta.Grind.M✝ Lean.Expr | null | false |
Std.Http.Version.v11 | Std.Http.Data.Version | Std.Http.Version | `HTTP/1.1`
| true |
Cardinal.isNormal_ord | Mathlib.SetTheory.Ordinal.Basic | Order.IsNormal Cardinal.ord | null | true |
NonUnitalSubalgebra.instIsTopologicalSemiring | Mathlib.Topology.Algebra.NonUnitalAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : NonUnitalSemiring A]
[inst_3 : Module R A] [IsTopologicalSemiring A] (s : NonUnitalSubalgebra R A), IsTopologicalSemiring ↥s | null | true |
FirstOrder.Language.BoundedFormula.IsQF.below.rec | Mathlib.ModelTheory.Complexity | ∀ {L : FirstOrder.Language} {α : Type u'} {n : ℕ} {motive : (a : L.BoundedFormula α n) → a.IsQF → Prop}
{motive_1 : {a : L.BoundedFormula α n} → (t : a.IsQF) → FirstOrder.Language.BoundedFormula.IsQF.below t → Prop},
motive_1 ⋯ ⋯ →
(∀ {φ : L.BoundedFormula α n} (h : φ.IsAtomic), motive_1 ⋯ ⋯) →
(∀ {φ₁ φ₂ ... | null | false |
_private.Qq.Macro.0.Qq.Impl.floatLevelAntiquot'.match_1 | Qq.Macro | (motive : Lean.Syntax → Sort u_1) →
(stx : Lean.Syntax) →
((i : Lean.SourceInfo) →
(k : Lean.SyntaxNodeKind) → (args : Array Lean.Syntax) → motive (Lean.Syntax.node i k args)) →
((stx : Lean.Syntax) → motive stx) → motive stx | null | false |
CategoryTheory.«term_ᘁ» | Mathlib.CategoryTheory.Monoidal.Rigid.Basic | Lean.TrailingParserDescr | The right dual of the object `X`. | true |
Std.Do.ExceptConds._f | Std.Do.PostCond | (x : Std.Do.PostShape) → Std.Do.PostShape.below x → Type u | null | false |
Submonoid.instMin._proof_1 | Mathlib.Algebra.Group.Submonoid.Defs | ∀ {M : Type u_1} [inst : MulOneClass M] (S₁ S₂ : Submonoid M) {a b : M},
a ∈ ↑S₁ ∩ ↑S₂ → b ∈ ↑S₁ ∩ ↑S₂ → a * b ∈ ↑S₁ ∩ ↑S₂ | null | false |
_private.Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit.0.CategoryTheory.Limits.colimitLimitToLimitColimit_surjective._simp_1_3 | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesFiniteLimit | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type w}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {X Y Z : C}
(f : X ⟶ Y) (g : Y ⟶ Z) (x : CategoryTheory.ToType X),
(CategoryTheory.ConcreteCategory.hom g) ((Cate... | null | false |
CategoryTheory.Limits.pullbackDiagonalMapIso.inv | Mathlib.CategoryTheory.Limits.Shapes.Diagonal | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{X Y : C} →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
{U V₁ V₂ : C} →
(f : X ⟶ Y) →
(i : U ⟶ Y) →
(i₁ : V₁ ⟶ CategoryTheory.Limits.pullback f i) →
(i₂ : V₂ ⟶ CategoryTheory.Li... | The underlying inverse of `pullbackDiagonalIso` | true |
Int.mul_fdiv_add_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a | null | true |
TensorProduct.LieModule.lie_tmul_right | Mathlib.Algebra.Lie.TensorProduct | ∀ {R : Type u} [inst : CommRing R] {L : Type v} {M : Type w} {N : Type w₁} [inst_1 : LieRing L]
[inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M]
[inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N] [inst_9 : LieRingModule L N]
[inst_10 : ... | null | true |
Ordinal.lift_zero | Mathlib.SetTheory.Ordinal.Basic | Ordinal.lift.{u_2, u_1} 0 = 0 | null | true |
Polynomial.aevalEquiv | Mathlib.Algebra.Polynomial.AlgebraMap | (R : Type u) →
(A : Type z) → [inst : CommSemiring R] → [inst_1 : Semiring A] → [inst_2 : Algebra R A] → A ≃ (Polynomial R →ₐ[R] A) | Given a valuation `x` of the variable in an `R`-algebra `A`, the bijection induced by the unique
`R`-algebra homomorphism from `R[X]` to `A` sending `X` to `x`. | true |
dvd_iff_padicValNat_ne_zero | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p n : ℕ} [Fact (Nat.Prime p)], n ≠ 0 → (p ∣ n ↔ padicValNat p n ≠ 0) | null | true |
groupHomology.H1CoresCoinf_X₃ | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u, u, u} k G) (S : Subgroup G) [inst_2 : S.Normal],
(groupHomology.H1CoresCoinf A S).X₃ = groupHomology.H1 (A.quotientToCoinvariants S) | null | true |
_private.Init.Data.UInt.Bitwise.0.USize.shiftRight_xor._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : USize}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
MeasureTheory.Submartingale.sum_mul_upcrossingStrat_le | Mathlib.Probability.Martingale.Upcrossing | ∀ {Ω : Type u_1} {m0 : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {a b : ℝ} {f : ℕ → Ω → ℝ} {N n : ℕ}
{ℱ : MeasureTheory.Filtration ℕ m0} [MeasureTheory.IsFiniteMeasure μ],
MeasureTheory.Submartingale f ℱ μ →
∫ (x : Ω), (∑ k ∈ Finset.range n, MeasureTheory.upcrossingStrat a b f N k * (f (k + 1) - f k)) x ... | null | true |
instCommRingFreeCommRing._proof_30 | Mathlib.RingTheory.FreeCommRing | ∀ (α : Type u_1), autoParam (↑0 = 0) AddMonoidWithOne.natCast_zero._autoParam | null | false |
UInt8.toUInt64_add | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a + b).toUInt64 = (a.toUInt64 + b.toUInt64) % 256 | null | true |
SimpleGraph.Walk.penultimate | Mathlib.Combinatorics.SimpleGraph.Walk.Traversal | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → V | The penultimate vertex of a walk, or the only vertex in a nil walk. | true |
_private.Mathlib.Analysis.Normed.Algebra.Spectrum.0.spectrum._aux_Mathlib_Analysis_Normed_Algebra_Spectrum___unexpand_resolventSet_1 | Mathlib.Analysis.Normed.Algebra.Spectrum | Lean.PrettyPrinter.Unexpander | null | false |
_private.Mathlib.RingTheory.MvPolynomial.Basic.0.MvPolynomial.restrictSupport_add._simp_1_2 | Mathlib.RingTheory.MvPolynomial.Basic | ∀ {α : Type u_2} [inst : Add α] {s t : Set α} {a b : α}, a ∈ s → b ∈ t → (a + b ∈ s + t) = True | null | false |
CategoryTheory.Localization.Construction.natTransExtension._proof_1 | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {W : CategoryTheory.MorphismProperty C} {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F₁ F₂ : CategoryTheory.Functor W.Localization D}
(τ : W.Q.comp F₁ ⟶ W.Q.comp F₂) ⦃X Y : W.Localization⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.... | null | false |
Finsupp.leftInverse_lcomapDomain_mapDomain | Mathlib.LinearAlgebra.Finsupp.Defs | ∀ {α : Type u_1} {M : Type u_2} {R : Type u_5} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{β : Type u_8} (f : α → β) (hf : Function.Injective f),
Function.LeftInverse (⇑(Finsupp.lcomapDomain f hf)) (Finsupp.mapDomain f) | null | true |
CategoryTheory.ObjectProperty.strictLimitsClosureIter.eq_1 | Mathlib.CategoryTheory.ObjectProperty.LimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (P : CategoryTheory.ObjectProperty C) {α : Type t}
(J : α → Type u') [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] {β : Type w'} [inst_2 : LinearOrder β]
[inst_3 : SuccOrder β] [inst_4 : WellFoundedLT β] (b : β),
P.strictLimitsClosureIter J b ... | null | true |
FirstOrder.Language.Symbols.eq_1 | Mathlib.ModelTheory.Encoding | ∀ (L : FirstOrder.Language), L.Symbols = ((l : ℕ) × L.Functions l ⊕ (l : ℕ) × L.Relations l) | null | true |
PolynomialModule.instAddCommGroup._proof_2 | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(a : PolynomialModule R M), 0 + a = a | null | false |
_private.Init.Data.String.Lemmas.Pattern.Char.0.String.Slice.Pattern.Model.Char.revMatchAt?_eq_revMatchAt?_beq._simp_1_2 | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos pos' : s.Pos},
String.Slice.Pattern.Model.IsLongestRevMatchAt c pos pos' =
String.Slice.Pattern.Model.IsLongestRevMatchAt (fun x => x == c) pos pos' | null | false |
Convexity.StdSimplex.barycenter._proof_1 | Mathlib.Geometry.Convex.ConvexSpace.Barycenter | ∀ {M : Type u_1} [Nonempty M] [inst : Fintype M], Finset.univ.Nonempty | null | false |
Lean.Widget.instToJsonRpcEncodablePacket.toJson._@.Lean.Widget.InteractiveGoal.2427803292._hygCtx._hyg.37 | Lean.Widget.InteractiveGoal | Lean.Widget.RpcEncodablePacket✝ → Lean.Json | null | false |
_private.Mathlib.Algebra.Homology.Factorizations.CM5a.0.CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.CofFibFactorizationQuasiIsoLE.fromNext._proof_1 | Mathlib.Algebra.Homology.Factorizations.CM5a | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{K L : CochainComplex C ℤ} {f : K ⟶ L} [inst_2 : CategoryTheory.EnoughInjectives C] {n₀ : ℤ}
(F : CochainComplex.Plus.modelCategoryQuillen.cm5a_cof.CofFibFactorizationQuasiIsoLE✝ f n₀) (n₁ : ℤ)
(hn₁ : n₀ + 1 = n₁), ... | null | false |
ProbabilityTheory.Kernel.IsMarkovKernel.comapRight | Mathlib.Probability.Kernel.Basic | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {γ : Type u_4}
{mγ : MeasurableSpace γ} {f : γ → β} (κ : ProbabilityTheory.Kernel α β) (hf : MeasurableEmbedding f),
(∀ (a : α), (κ a) (Set.range f) = 1) → ProbabilityTheory.IsMarkovKernel (κ.comapRight hf) | null | true |
Std.ExtDHashMap.Const.getD_alter_self | Std.Data.ExtDHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {β : Type v} {m : Std.ExtDHashMap α fun x => β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {fallback : β} {f : Option β → Option β},
Std.ExtDHashMap.Const.getD (Std.ExtDHashMap.Const.alter m k f) k fallback =
(f (Std.ExtDHashMap.Const.get? m k)).getD fa... | null | true |
pinGroup.val_inv_toUnits_apply | Mathlib.LinearAlgebra.CliffordAlgebra.SpinGroup | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{Q : QuadraticForm R M} (x : ↥(pinGroup Q)), ↑(pinGroup.toUnits x)⁻¹ = ↑x⁻¹ | null | true |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.maxKey_alter_eq_self._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 |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getElimNameInfo.throwUnsupportedInductionType | Lean.Elab.Tactic.Induction | Lean.Name → String → Lean.Elab.Tactic.TacticM Unit | null | true |
Filter.blimsup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → {β : Type u_2} → [ConditionallyCompleteLattice α] → (β → α) → Filter β → (β → Prop) → α | The `blimsup` of a function `u` along a filter `f`, bounded by a predicate `p`, is the infimum
of the `a` such that the inequality `u x ≤ a` eventually holds for `f`, whenever `p x` holds. | true |
_private.Lean.Elab.AutoBound.0.Lean.Elab.checkValidAutoBoundImplicitName._sparseCasesOn_2 | Lean.Elab.AutoBound | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | null | false |
compl_compl_inf_distrib | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a b : α), (a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ | null | true |
Lean.Meta.Grind.Counters.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.Counters → Sort u} →
((thm : Lean.PHashMap Lean.Meta.Grind.Origin ℕ) →
(fvarUserNames : Lean.PHashMap Lean.FVarId Lean.Name) →
(case apps : Lean.PHashMap Lean.Name ℕ) →
motive { thm := thm, fvarUserNames := fvarUserNames, case := case, apps := apps }) →
(t : Lean.... | null | false |
Lean.Data.AC.eval._sunfold | Init.Data.AC | {α : Sort u_1} → (β : Sort u) → [Lean.Data.AC.EvalInformation α β] → α → Lean.Data.AC.Expr → β | null | false |
Num.ctorElimType | Mathlib.Data.Num.Basic | {motive : Num → Sort u} → ℕ → Sort (max 1 u) | null | false |
AddSubgroup.isAddUnit_of_mem_ofAddUnits | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : AddMonoid M] (S : AddSubgroup (AddUnits M)) {x : M}, x ∈ S.ofAddUnits → IsAddUnit x | null | true |
Polynomial.scaleRoots_aeval_eq_zero_of_aeval_div_eq_zero | Mathlib.RingTheory.Polynomial.ScaleRoots | ∀ {R : Type u_1} {K : Type u_4} [inst : CommSemiring R] [inst_1 : Field K] [inst_2 : Algebra R K],
Function.Injective ⇑(algebraMap R K) →
∀ {p : Polynomial R} {r s : R},
(Polynomial.aeval ((algebraMap R K) r / (algebraMap R K) s)) p = 0 →
s ∈ nonZeroDivisors R → (Polynomial.aeval ((algebraMap R K) r... | null | true |
SimpleGraph.Copy.completeBipartiteGraph._proof_3 | Mathlib.Combinatorics.SimpleGraph.Bipartite | ∀ {V : Type u_1} {α : Type u_2} {β : Type u_3} (left : Finset V) (this : Nonempty (α ↪ ↥left)) {s₁ : α ⊕ β}
(hs₁ : s₁.isLeft = true), (Subtype.val ∘ ⇑(Classical.arbitrary (α ↪ ↥left))) (s₁.getLeft hs₁) ∈ ↑left | null | false |
Rat.pow_def._proof_2 | Init.Data.Rat.Lemmas | ∀ (q : ℚ) (n : ℕ), (q.num ^ n).natAbs.Coprime (q.den ^ n) | null | false |
SkewPolynomial.support_update_ne_zero | Mathlib.Algebra.SkewPolynomial.Basic | ∀ {R : Type u_1} [inst : Semiring R] (p : SkewPolynomial R) (n : ℕ) {a : R},
a ≠ 0 → (p.update n a).support = insert n p.support | null | true |
CategoryTheory.Pseudofunctor.StrongTrans.rightUnitor_inv_as_app | Mathlib.CategoryTheory.Bicategory.FunctorBicategory.Pseudo | ∀ (B : Type u₁) [inst : CategoryTheory.Bicategory B] (C : Type u₂) [inst_1 : CategoryTheory.Bicategory C]
{F G : CategoryTheory.Pseudofunctor B C} (η : F ⟶ G) (a : B),
(CategoryTheory.Bicategory.rightUnitor η).inv.as.app a = (CategoryTheory.Bicategory.rightUnitor (η.app a)).inv | null | true |
Set.ofPred_false | Mathlib.Data.Set.Basic | ∀ {α : Type u}, {_a | False} = ∅ | null | true |
ContinuousLinearMap.coe_sub' | Mathlib.Topology.Algebra.Module.ContinuousLinearMap.Basic | ∀ {F : Type u_2} {α : Type u_4} {β : Type u_5} [inst : FunLike F α β] [inst_1 : Sub F] [inst_2 : Sub β]
[IsSubApply F α β] (f g : F), ⇑(f - g) = ⇑f - ⇑g | **Alias** of `FunLike.coe_sub`. | true |
Std.DHashMap.Internal.Raw₀.get!_eq_default | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α], (↑m).WF → ∀ {a : α} [inst_3 : Inhabited (β a)], m.contains a = false → m.get! a = default | null | true |
_private.Lean.Meta.DiscrTree.Main.0.Lean.Meta.DiscrTree.isBadKey._sparseCasesOn_1 | Lean.Meta.DiscrTree.Main | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((a : Lean.Literal) → motive (Lean.Expr.lit a)) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
((fvarId : Lean.FVarId) → motive (Lean.Expr.fvar fvarId)) →
((typeName : Lean.Name) → (idx : ℕ) → (... | null | false |
_private.Mathlib.NumberTheory.Bernoulli.0.Bernoulli.pIntegral_bernoulli_even_term._proof_1_1 | Mathlib.NumberTheory.Bernoulli | ∀ {k m : ℕ}, m < k → 2 * k - 2 * m = 2 * k - 2 * m - 1 + 1 | null | false |
Std.ExtHashMap.getKey_inter | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k : α} {h_mem : k ∈ m₁ ∩ m₂}, (m₁ ∩ m₂).getKey k h_mem = m₁.getKey k ⋯ | null | true |
Ordinal.instSuccOrder._proof_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {a b : Ordinal.{u_1}}, a + 1 ≤ b ↔ a < b | null | false |
MvPolynomial.expand_bind₁ | Mathlib.Algebra.MvPolynomial.Expand | ∀ {σ : Type u_1} {τ : Type u_2} {R : Type u_3} [inst : CommSemiring R] (p : ℕ) (f : σ → MvPolynomial τ R)
(φ : MvPolynomial σ R),
(MvPolynomial.expand p) ((MvPolynomial.bind₁ f) φ) = (MvPolynomial.bind₁ fun i => (MvPolynomial.expand p) (f i)) φ | null | true |
_private.Lean.Compiler.LCNF.ExtractClosed.0.Lean.Compiler.LCNF.ExtractClosed.shouldExtractLetValue._sparseCasesOn_8 | Lean.Compiler.LCNF.ExtractClosed | {motive : Lean.Compiler.LCNF.LitValue → Sort u} →
(t : Lean.Compiler.LCNF.LitValue) →
((val : String) → motive (Lean.Compiler.LCNF.LitValue.str val)) →
((val : ℕ) → motive (Lean.Compiler.LCNF.LitValue.nat val)) → (Nat.hasNotBit 3 t.ctorIdx → motive t) → motive t | null | false |
QuadraticAlgebra.C_neg | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : NegZeroClass R] (x : R), QuadraticAlgebra.C (-x) = -QuadraticAlgebra.C x | null | true |
Nat.image_sub_const_Ico | Mathlib.Order.Interval.Finset.Nat | ∀ {a b c : ℕ}, c ≤ a → Finset.image (fun x => x - c) (Finset.Ico a b) = Finset.Ico (a - c) (b - c) | null | true |
Submodule.inclusionSpan | Mathlib.LinearAlgebra.Span.Basic | {R : Type u_1} →
{M : Type u_4} →
(S : Type u_7) →
[inst : Semiring R] →
[inst_1 : AddCommMonoid M] →
[inst_2 : Module R M] →
[inst_3 : Semiring S] →
[inst_4 : SMul R S] →
[inst_5 : Module S M] →
[inst_6 : IsScalarTower R S M] → (... | The inclusion of an `R`-submodule into its `S`-span, as an `R`-linear map. | true |
RBTree.RBNode.find?_insert_self | Batteries.Recycling.RBTree.Lemmas | ∀ {α : Type u_1} {cmp : α → α → Ordering} {cut : α → Ordering} {c : RBTree.RBColor} {n : ℕ} {v : α} [Std.TransCmp cmp]
[RBTree.RBNode.IsStrictCut cmp cut] {t : RBTree.RBNode α},
t.Balanced c n →
RBTree.RBNode.Ordered cmp t → cut v = Ordering.eq → RBTree.RBNode.find? cut (RBTree.RBNode.insert cmp t v) = some v | null | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.isDefEqMainImpl.match_1 | Lean.Meta.Sym.Pattern | (motive : Lean.Expr → Lean.Expr → Sort u_1) →
(t s : Lean.Expr) →
((l₁ l₂ : Lean.Literal) → motive (Lean.Expr.lit l₁) (Lean.Expr.lit l₂)) →
((u v : Lean.Level) → motive (Lean.Expr.sort u) (Lean.Expr.sort v)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(bin... | null | false |
CategoryTheory.GrothendieckTopology.toPrecoverage_top | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C], ⊤.toPrecoverage = ⊤ | null | true |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.withNotFirst | Lean.Elab.Syntax | {α : Type} → Lean.Elab.Term.ToParserDescrM α → Lean.Elab.Term.ToParserDescrM α | null | true |
Std.Http.URI.instInhabitedRelativeRef | Std.Http.Data.URI.Basic | Inhabited Std.Http.URI.RelativeRef | null | true |
Std.TreeMap.Raw.size_diff_eq_size_left | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp],
t₁.WF → t₂.WF → (∀ a ∈ t₁, a ∉ t₂) → (t₁ \ t₂).size = t₁.size | null | true |
RCLike.instStarModuleReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], StarModule ℝ K | null | true |
CategoryTheory.Limits.HasImageMap.mk'._flat_ctor | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g : CategoryTheory.Arrow C}
[inst_1 : CategoryTheory.Limits.HasImage f.hom] [inst_2 : CategoryTheory.Limits.HasImage g.hom] {sq : f ⟶ g},
Nonempty (CategoryTheory.Limits.ImageMap sq) → CategoryTheory.Limits.HasImageMap sq | null | false |
Lean.ParametricAttributeExtra.mk.noConfusion | Batteries.Lean.AttributeExtra | {α : Type} →
{P : Sort u} →
{attr : Lean.ParametricAttribute α} →
{base : Std.HashMap Lean.Name α} →
{attr' : Lean.ParametricAttribute α} →
{base' : Std.HashMap Lean.Name α} →
{ attr := attr, base := base } = { attr := attr', base := base' } → (attr ≍ attr' → base ≍ base' → P) ... | null | false |
_private.Mathlib.NumberTheory.JacobiSum.Basic.0.gaussSum_pow_eq_prod_jacobiSum_aux._simp_1_1 | Mathlib.NumberTheory.JacobiSum.Basic | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | null | false |
Stream'.Seq.drop_length'._unary | Mathlib.Data.Seq.Basic | ∀ {α : Type u} (_x : (_ : ℕ) ×' Stream'.Seq α), (_x.2.drop _x.1).length' = _x.2.length' - ↑_x.1 | null | false |
Lean.Grind.Linarith.instBEqPoly.beq.eq_def | Init.Grind.Ordered.Linarith | ∀ (x x_1 : Lean.Grind.Linarith.Poly),
Lean.Grind.Linarith.instBEqPoly.beq x x_1 =
match x, x_1 with
| Lean.Grind.Linarith.Poly.nil, Lean.Grind.Linarith.Poly.nil => true
| Lean.Grind.Linarith.Poly.add a a_1 a_2, Lean.Grind.Linarith.Poly.add b b_1 b_2 =>
a == b && (a_1 == b_1 && Lean.Grind.Linarith.in... | null | true |
Int.toNat_le._simp_1 | Init.Data.Int.LemmasAux | ∀ {m : ℤ} {n : ℕ}, (m.toNat ≤ n) = (m ≤ ↑n) | null | false |
TopologicalSpace.PositiveCompacts.mk.inj | Mathlib.Topology.Sets.Compacts | ∀ {α : Type u_4} {inst : TopologicalSpace α} {toCompacts : TopologicalSpace.Compacts α}
{interior_nonempty' : (interior toCompacts.carrier).Nonempty} {toCompacts_1 : TopologicalSpace.Compacts α}
{interior_nonempty'_1 : (interior toCompacts_1.carrier).Nonempty},
{ toCompacts := toCompacts, interior_nonempty' := in... | null | true |
ZMod.LFunction_eq_LSeries | Mathlib.NumberTheory.LSeries.ZMod | ∀ {N : ℕ} [inst : NeZero N] (Φ : ZMod N → ℂ) {s : ℂ}, 1 < s.re → ZMod.LFunction Φ s = LSeries (fun x => Φ ↑x) s | For `1 < re s` the congruence L-function agrees with the sum of the Dirichlet series. | true |
MulHom.snd | Mathlib.Algebra.Group.Prod | (M : Type u_3) → (N : Type u_4) → [inst : Mul M] → [inst_1 : Mul N] → M × N →ₙ* N | Given magmas `M`, `N`, the natural projection homomorphism from `M × N` to `N`. | true |
Set.image_const_div_Ici | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b : α),
(fun x => a / x) '' Set.Ici b = Set.Iic (a / b) | null | true |
CategoryTheory.NonPreadditiveAbelian.neg_add_cancel | Mathlib.CategoryTheory.Abelian.NonPreadditive | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.NonPreadditiveAbelian C] {X Y : C}
(a : X ⟶ Y), -a + a = 0 | null | true |
MeasureTheory.sdiff_mem_measurableCylinders | Mathlib.MeasureTheory.Constructions.Cylinders | ∀ {ι : Type u_1} {α : ι → Type u_2} [inst : (i : ι) → MeasurableSpace (α i)] {s t : Set ((i : ι) → α i)},
s ∈ MeasureTheory.measurableCylinders α →
t ∈ MeasureTheory.measurableCylinders α → s \ t ∈ MeasureTheory.measurableCylinders α | null | true |
CategoryTheory.Subobject.mapIsoToOrderIso | Mathlib.CategoryTheory.Subobject.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{X Y : C} → (X ≅ Y) → CategoryTheory.Subobject X ≃o CategoryTheory.Subobject Y | In fact, there's a type level bijection between the subobjects of isomorphic objects,
which preserves the order. | true |
Mathlib.Meta.Multiset.ProveZeroOrConsResult.cons | Mathlib.Tactic.NormNum.BigOperators | {u : Lean.Level} →
{α : Q(Type u)} →
{s : Q(Multiset «$α»)} →
(a : Q(«$α»)) → (s' : Q(Multiset «$α»)) → Q(«$s» = «$a» ::ₘ «$s'») → Mathlib.Meta.Multiset.ProveZeroOrConsResult s | The set equals `a` inserted into the strict subset `s'`. | true |
AffineEquiv.arrowCongr._proof_1 | Mathlib.LinearAlgebra.AffineSpace.AffineEquiv | ∀ {P₁ : Type u_6} {P₂ : Type u_1} {P₃ : Type u_7} {P₄ : Type u_2} {V₁ : Type u_8} {V₂ : Type u_3} {V₃ : Type u_9}
{V₄ : Type u_4} [inst : AddCommGroup V₁] [inst_1 : AddCommGroup V₂] [inst_2 : AddCommGroup V₃]
[inst_3 : AddCommGroup V₄] [inst_4 : AddTorsor V₁ P₁] [inst_5 : AddTorsor V₂ P₂] [inst_6 : AddTorsor V₃ P₃]... | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.