name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Int.mul_fdiv_add_fmod | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), b * a.fdiv b + a.fmod b = a |
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 : LieModule R L N] (x : L) (m : M) (n : N), ⁅x, m ⊗ₜ[R] n⁆ = ⁅x, m⁆ ⊗ₜ[R] n + m ⊗ₜ[R] ⁅x, n⁆ |
Ordinal.lift_zero | Mathlib.SetTheory.Ordinal.Basic | Ordinal.lift.{u_2, u_1} 0 = 0 |
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) |
dvd_iff_padicValNat_ne_zero | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p n : ℕ} [Fact (Nat.Prime p)], n ≠ 0 → (p ∣ n ↔ padicValNat p n ≠ 0) |
groupHomology.H1CoresCoinf_X₃ | Mathlib.RepresentationTheory.Homological.GroupHomology.Functoriality | ∀ {k G : Type u} [inst : CommRing k] [inst_1 : Group G] (A : Rep k G) (S : Subgroup G) [inst_2 : S.Normal],
(groupHomology.H1CoresCoinf A S).X₃ = groupHomology.H1 (A.quotientToCoinvariants S) |
_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) |
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 ∂μ ≤
∫ (x : Ω), f n x ∂μ - ∫ (x : Ω), f 0 x ∂μ |
AddSubsemigroup.addCommSemigroupTopologicalClosure.match_1 | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : AddSemigroup M] [inst_2 : SeparatelyContinuousAdd M]
(s : AddSubsemigroup M) (motive : ↥s.topologicalClosure → Prop) (x : ↥s.topologicalClosure),
(∀ (y : M) (hy : y ∈ s.topologicalClosure), motive ⟨y, hy⟩) → motive x |
UInt8.toUInt64_add | Init.Data.UInt.Lemmas | ∀ (a b : UInt8), (a + b).toUInt64 = (a.toUInt64 + b.toUInt64) % 256 |
SimpleGraph.Walk.penultimate | Mathlib.Combinatorics.SimpleGraph.Walks.Traversal | {V : Type u} → {G : SimpleGraph V} → {u v : V} → G.Walk u v → V |
_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 |
_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 |
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.comp (F₁.map f) (CategoryTheory.Localization.Construction.NatTransExtension.app τ Y) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Localization.Construction.NatTransExtension.app τ X) (F₂.map f) |
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_9} (f : α → β) (hf : Function.Injective f),
Function.LeftInverse (⇑(Finsupp.lcomapDomain f hf)) (Finsupp.mapDomain f) |
FirstOrder.Language.Symbols.eq_1 | Mathlib.ModelTheory.Encoding | ∀ (L : FirstOrder.Language), L.Symbols = ((l : ℕ) × L.Functions l ⊕ (l : ℕ) × L.Relations l) |
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 = transfiniteIterate (fun Q => Q.strictLimitsClosureStep J) b P |
_private.Lean.Elab.StructInstHint.0.Lean.Elab.Term.StructInst.FieldsHintView.mk.sizeOf_spec | Lean.Elab.StructInstHint | ∀ (initFieldPos? lastFieldTailPos? : Option String.Pos.Raw) (hasWith : Bool) (numFields : ℕ)
(openingPos leaderPos leaderTailPos closingPos : String.Pos.Raw),
sizeOf
{ initFieldPos? := initFieldPos?, lastFieldTailPos? := lastFieldTailPos?, hasWith := hasWith,
numFields := numFields, openingPos := openingPos, leaderPos := leaderPos, leaderTailPos := leaderTailPos,
closingPos := closingPos } =
1 + sizeOf initFieldPos? + sizeOf lastFieldTailPos? + sizeOf hasWith + sizeOf numFields + sizeOf openingPos +
sizeOf leaderPos +
sizeOf leaderTailPos +
sizeOf closingPos |
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) |
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 fallback |
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⁻¹ |
_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) |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.getElimNameInfo.throwUnsupportedInductionType | Lean.Elab.Tactic.Induction | Lean.Name → String → Lean.Elab.Tactic.TacticM PUnit.{1} |
Filter.blimsup | Mathlib.Order.LiminfLimsup | {α : Type u_1} → {β : Type u_2} → [ConditionallyCompleteLattice α] → (β → α) → Filter β → (β → Prop) → α |
Field.Emb.Cardinal.succEquiv._proof_9 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_2} {E : Type u_1} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
(i : (Module.rank F E).ord.ToType),
Algebra.IsAlgebraic
↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F E) ∘ Field.Emb.Cardinal.leastExt F E '' Set.Iio i))
↥(↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F E) ∘ Field.Emb.Cardinal.leastExt F E ''
Set.Iio i)))⟮(Field.Emb.Cardinal.wellOrderedBasis F E) (Field.Emb.Cardinal.leastExt F E i)⟯ |
_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 |
compl_compl_inf_distrib | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : HeytingAlgebra α] (a b : α), (a ⊓ b)ᶜᶜ = aᶜᶜ ⊓ bᶜᶜ |
Lean.Meta.Grind.Counters.rec | Lean.Meta.Tactic.Grind.Types | {motive : Lean.Meta.Grind.Counters → Sort u} →
((thm : Lean.PHashMap Lean.Meta.Grind.Origin ℕ) →
(case apps : Lean.PHashMap Lean.Name ℕ) → motive { thm := thm, case := case, apps := apps }) →
(t : Lean.Meta.Grind.Counters) → motive t |
Lean.Data.AC.eval._sunfold | Init.Data.AC | {α : Sort u_1} → (β : Sort u) → [Lean.Data.AC.EvalInformation α β] → α → Lean.Data.AC.Expr → β |
Num.ctorElimType | Mathlib.Data.Num.Basic | {motive : Num → Sort u} → ℕ → Sort (max 1 u) |
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 |
_private.Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups.0.Subgroup.isArithmetic_iff_finiteIndex._simp_1_3 | Mathlib.NumberTheory.ModularForms.ArithmeticSubgroups | ∀ {G : Type u_1} {G' : Type u_2} [inst : Group G] [inst_1 : Group G'] (H : Subgroup G) (f : G' →* G) (K : Subgroup G'),
H.relIndex (Subgroup.map f K) = (Subgroup.comap f H).relIndex K |
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)) (p.scaleRoots s) = 0 |
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 |
Rat.pow_def._proof_2 | Init.Data.Rat.Lemmas | ∀ (q : ℚ) (n : ℕ), (q.num ^ n).natAbs.Coprime (q.den ^ n) |
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 |
ContinuousLinearMap.coe_sub' | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R : Type u_1} [inst : Ring R] {R₂ : Type u_2} [inst_1 : Ring R₂] {M : Type u_4} [inst_2 : TopologicalSpace M]
[inst_3 : AddCommGroup M] {M₂ : Type u_5} [inst_4 : TopologicalSpace M₂] [inst_5 : AddCommGroup M₂]
[inst_6 : Module R M] [inst_7 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_8 : IsTopologicalAddGroup M₂]
(f g : M →SL[σ₁₂] M₂), ⇑(f - g) = ⇑f - ⇑g |
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 |
_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 : ℕ) → (struct : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType body binderInfo)) →
(Nat.hasNotBit 2706 t.ctorIdx → motive t) → motive t |
Lean.IR.ExpandResetReuse.Context.mk._flat_ctor | Lean.Compiler.IR.ExpandResetReuse | Lean.IR.ExpandResetReuse.ProjMap → Lean.IR.ExpandResetReuse.Context |
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 ⋯ |
Ordinal.instSuccOrder._proof_1 | Mathlib.SetTheory.Ordinal.Basic | ∀ {a b : Ordinal.{u_1}}, (fun o => o + 1) a ≤ b ↔ a < b |
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)) φ |
_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 |
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 |
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) |
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] → (p : Submodule R M) → ↥p →ₗ[R] ↥(Submodule.span S ↑p) |
_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) →
(binderInfo : Lean.BinderInfo) →
(binderName_1 : Lean.Name) →
(binderType_1 body_1 : Lean.Expr) →
(binderInfo_1 : Lean.BinderInfo) →
motive (Lean.Expr.lam binderName binderType body binderInfo)
(Lean.Expr.lam binderName_1 binderType_1 body_1 binderInfo_1)) →
((binderName : Lean.Name) →
(binderType body : Lean.Expr) →
(binderInfo : Lean.BinderInfo) →
(binderName_1 : Lean.Name) →
(binderType_1 body_1 : Lean.Expr) →
(binderInfo_1 : Lean.BinderInfo) →
motive (Lean.Expr.forallE binderName binderType body binderInfo)
(Lean.Expr.forallE binderName_1 binderType_1 body_1 binderInfo_1)) →
((data : Lean.MData) → (t x : Lean.Expr) → motive (Lean.Expr.mdata data t) x) →
((x : Lean.Expr) → (data : Lean.MData) → (s : Lean.Expr) → motive x (Lean.Expr.mdata data s)) →
((fvarId₁ fvarId₂ : Lean.FVarId) → motive (Lean.Expr.fvar fvarId₁) (Lean.Expr.fvar fvarId₂)) →
((declName₁ : Lean.Name) →
(us₁ : List Lean.Level) →
(declName₂ : Lean.Name) →
(us₂ : List Lean.Level) →
motive (Lean.Expr.const declName₁ us₁) (Lean.Expr.const declName₂ us₂)) →
((deBruijnIndex : ℕ) → (x : Lean.Expr) → motive (Lean.Expr.bvar deBruijnIndex) x) →
((x : Lean.Expr) → (deBruijnIndex : ℕ) → motive x (Lean.Expr.bvar deBruijnIndex)) →
((typeName : Lean.Name) →
(idx : ℕ) → (struct x : Lean.Expr) → motive (Lean.Expr.proj typeName idx struct) x) →
((x : Lean.Expr) →
(typeName : Lean.Name) →
(idx : ℕ) → (struct : Lean.Expr) → motive x (Lean.Expr.proj typeName idx struct)) →
((declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) →
(x : Lean.Expr) → motive (Lean.Expr.letE declName type value body nondep) x) →
((x : Lean.Expr) →
(declName : Lean.Name) →
(type value body : Lean.Expr) →
(nondep : Bool) → motive x (Lean.Expr.letE declName type value body nondep)) →
((x x_1 : Lean.Expr) → motive x x_1) → motive t s |
CategoryTheory.GrothendieckTopology.toPrecoverage_top | Mathlib.CategoryTheory.Sites.PrecoverageToGrothendieck | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} C], ⊤.toPrecoverage = ⊤ |
BitVec.DivModState.lawful_init._proof_4 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} (args : BitVec.DivModArgs w), 0#w < args.d → BitVec.DivModState.Lawful args (BitVec.DivModState.init w) |
_private.Lean.Elab.Syntax.0.Lean.Elab.Term.withNotFirst | Lean.Elab.Syntax | {α : Type} → Lean.Elab.Term.ToParserDescrM α → Lean.Elab.Term.ToParserDescrM α |
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 |
RCLike.instStarModuleReal | Mathlib.Analysis.RCLike.Basic | ∀ {K : Type u_1} [inst : RCLike K], StarModule ℝ K |
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 |
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) → P |
_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 |
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 |
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.instBEqPoly.beq a_2 b_2)
| x, x_2 => false |
unitary.path | Mathlib.Analysis.CStarAlgebra.Unitary.Connected | {A : Type u_1} → [inst : CStarAlgebra A] → (u v : ↥(unitary A)) → ‖↑v - ↑u‖ < 2 → Path u v |
Int.toNat_le._simp_1 | Init.Data.Int.LemmasAux | ∀ {m : ℤ} {n : ℕ}, (m.toNat ≤ n) = (m ≤ ↑n) |
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' := interior_nonempty' } =
{ toCompacts := toCompacts_1, interior_nonempty' := interior_nonempty'_1 } →
toCompacts = toCompacts_1 |
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 |
MulHom.snd | Mathlib.Algebra.Group.Prod | (M : Type u_3) → (N : Type u_4) → [inst : Mul M] → [inst_1 : Mul N] → M × N →ₙ* N |
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) |
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 |
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 |
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 |
ContinuousNeg.mk._flat_ctor | Mathlib.Topology.Algebra.Group.Defs | ∀ {G : Type u} [inst : TopologicalSpace G] [inst_1 : Neg G], (Continuous fun a => -a) → ContinuousNeg G |
PrimrecPred.comp | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Primcodable α] [inst_1 : Primcodable β] {p : β → Prop} {f : α → β},
PrimrecPred p → Primrec f → PrimrecPred fun a => p (f a) |
PosNum.lor._unsafe_rec | Mathlib.Data.Num.Bitwise | PosNum → PosNum → PosNum |
Mathlib.Tactic.Ring.ExBase.eq._unsafe_rec | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{sα : Q(CommSemiring «$α»)} →
{a b : Q(«$α»)} → Mathlib.Tactic.Ring.ExBase sα a → Mathlib.Tactic.Ring.ExBase sα b → Bool |
OrderDual.instAddCancelCommMonoid | Mathlib.Algebra.Order.Group.Synonym | {α : Type u_1} → [h : AddCancelCommMonoid α] → AddCancelCommMonoid αᵒᵈ |
Std.DTreeMap.Internal.Zipper.prependMapGE._unsafe_rec | Std.Data.DTreeMap.Internal.Zipper | {α : Type u} →
{β : α → Type v} →
[Ord α] → Std.DTreeMap.Internal.Impl α β → α → Std.DTreeMap.Internal.Zipper α β → Std.DTreeMap.Internal.Zipper α β |
CochainComplex.mappingCocone.lift._proof_3 | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) {M : CochainComplex C ℤ} (α : M ⟶ K)
(β : CochainComplex.HomComplex.Cochain M L (-1)),
CochainComplex.HomComplex.δ (-1) 0 β +
CochainComplex.HomComplex.Cochain.ofHom (CategoryTheory.CategoryStruct.comp α φ) =
0 →
CochainComplex.HomComplex.δ (-1) 0 β +
(↑(CochainComplex.HomComplex.Cocycle.ofHom α)).comp (CochainComplex.HomComplex.Cochain.ofHom φ) ⋯ =
0 |
IsSMulRegular.of_mul_eq_one | Mathlib.Algebra.Regular.SMul | ∀ {R : Type u_1} {M : Type u_3} {a b : R} [inst : Monoid R] [inst_1 : MulAction R M], a * b = 1 → IsSMulRegular M b |
frequently_nhds_iff | Mathlib.Topology.Neighborhoods | ∀ {X : Type u} [inst : TopologicalSpace X] {x : X} {p : X → Prop},
(∃ᶠ (y : X) in nhds x, p y) ↔ ∀ (U : Set X), x ∈ U → IsOpen U → ∃ y ∈ U, p y |
Lean.ImportState.ctorIdx | Lean.Environment | Lean.ImportState → ℕ |
TensorProduct.AlgebraTensorModule.map_smul_right | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : AddCommMonoid P]
[inst_10 : Module R P] [inst_11 : Module A P] [inst_12 : IsScalarTower R A P] [inst_13 : AddCommMonoid Q]
[inst_14 : Module R Q] (r : R) (f : M →ₗ[A] P) (g : N →ₗ[R] Q),
TensorProduct.AlgebraTensorModule.map f (r • g) = r • TensorProduct.AlgebraTensorModule.map f g |
Num.gcdAux.eq_1 | Mathlib.Data.Num.ZNum | ∀ (x x_1 : Num), Num.gcdAux 0 x x_1 = x_1 |
_private.Mathlib.Analysis.Asymptotics.Lemmas.0.Asymptotics.IsLittleO.tendsto_inv_smul_nhds_zero._simp_1_1 | Mathlib.Analysis.Asymptotics.Lemmas | ∀ {α : Type u_2} [inst : NormedDivisionRing α] (a : α), ‖a‖⁻¹ = ‖a⁻¹‖ |
_private.Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion.0.Tactic.ComputeAsymptotics.Seq.dist_eq_one_of_head._simp_1_2 | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (h : ∃ n, p n), (Nat.find h = 0) = p 0 |
CategoryTheory.Limits.cospanCompIso_hom_app_right | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Cospan | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z),
(CategoryTheory.Limits.cospanCompIso F f g).hom.app CategoryTheory.Limits.WalkingCospan.right =
CategoryTheory.CategoryStruct.id
(((CategoryTheory.Limits.cospan f g).comp F).obj CategoryTheory.Limits.WalkingCospan.right) |
CategoryTheory.Triangulated.SpectralObject.instCategory._proof_7 | Mathlib.CategoryTheory.Triangulated.SpectralObject | ∀ {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.Limits.HasZeroObject C]
[inst_3 : CategoryTheory.HasShift C ℤ] [inst_4 : CategoryTheory.Preadditive C]
[inst_5 : ∀ (n : ℤ), (CategoryTheory.shiftFunctor C n).Additive] [inst_6 : CategoryTheory.Pretriangulated C]
{X Y : CategoryTheory.Triangulated.SpectralObject C ι} (f : X.Hom Y),
{ hom := CategoryTheory.CategoryStruct.comp { hom := CategoryTheory.CategoryStruct.id X.ω₁, comm := ⋯ }.hom f.hom,
comm := ⋯ } =
f |
_private.Mathlib.Algebra.GroupWithZero.WithZero.0.WithZero.monoidWithZeroHom_ext.match_1_1 | Mathlib.Algebra.GroupWithZero.WithZero | ∀ {α : Type u_1} (motive : WithZero α → Prop) (x : WithZero α),
(∀ (a : Unit), motive none) → (∀ (g : α), motive (some g)) → motive x |
stdOrthonormalBasis | Mathlib.Analysis.InnerProductSpace.PiL2 | (𝕜 : Type u_7) →
[inst : RCLike 𝕜] →
(E : Type u_8) →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] → [FiniteDimensional 𝕜 E] → OrthonormalBasis (Fin (Module.finrank 𝕜 E)) 𝕜 E |
CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl_asSigma | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} {Y : CategoryTheory.Limits.FormalCoproduct C}
(f : (CategoryTheory.Limits.FormalCoproduct.incl C).obj X ⟶ Y),
CategoryTheory.Limits.FormalCoproduct.Hom.fromIncl (CategoryTheory.Limits.FormalCoproduct.Hom.asSigma f).fst
(CategoryTheory.Limits.FormalCoproduct.Hom.asSigma f).snd =
f |
Std.DTreeMap.Internal.Impl.getKey?_eq_some_getKey! | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α]
[inst : Inhabited α], t.WF → ∀ {a : α}, a ∈ t → t.getKey? a = some (t.getKey! a) |
Submodule.tensorSpanEquivSpan | Mathlib.LinearAlgebra.Span.TensorProduct | (R : Type u_1) →
(A : Type u_2) →
{M : Type u_3} →
[inst : CommSemiring R] →
[inst_1 : CommSemiring A] →
[inst_2 : Algebra R A] →
[inst_3 : AddCommMonoid M] →
[inst_4 : Module R M] →
[inst_5 : Module A M] →
[IsScalarTower R A M] →
[Algebra.IsEpi R A] →
[Module.Flat R A] →
(s : Set M) → TensorProduct R A ↥(Submodule.span R s) ≃ₗ[A] ↥(Submodule.span A s) |
Dvd.intro | Mathlib.Algebra.Divisibility.Basic | ∀ {α : Type u_1} [inst : Semigroup α] {a b : α} (c : α), a * c = b → a ∣ b |
CategoryTheory.Functor.IsEventuallyConstantTo.cone | Mathlib.CategoryTheory.Limits.Constructions.EventuallyConstant | {J : Type u_1} →
{C : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} C] →
{F : CategoryTheory.Functor J C} →
{i₀ : J} → F.IsEventuallyConstantTo i₀ → [CategoryTheory.IsCofiltered J] → CategoryTheory.Limits.Cone F |
mem_uniformity_isClosed | Mathlib.Topology.UniformSpace.Basic | ∀ {α : Type ua} [inst : UniformSpace α] {s : SetRel α α}, s ∈ uniformity α → ∃ t ∈ uniformity α, IsClosed t ∧ t ⊆ s |
CategoryTheory.LocallyDiscrete.mk.inj | Mathlib.CategoryTheory.Bicategory.LocallyDiscrete | ∀ {C : Type u} {as as_1 : C}, { as := as } = { as := as_1 } → as = as_1 |
_private.Std.Data.ExtDHashMap.Basic.0.Std.ExtDHashMap.get._proof_2 | Std.Data.ExtDHashMap.Basic | ∀ {α : Type u_1} {β : α → Type u_2} {x : BEq α} {x_1 : Hashable α} [inst : LawfulBEq α] (m : Std.ExtDHashMap α β),
∀ a ∈ m, ∀ (m_1 m' : Std.DHashMap α β), m = Std.ExtDHashMap.mk m_1 → m_1.Equiv m' → a ∈ m' |
RingCat.Colimits.Prequotient._sizeOf_1 | Mathlib.Algebra.Category.Ring.Colimits | {J : Type v} →
{inst : CategoryTheory.SmallCategory J} →
{F : CategoryTheory.Functor J RingCat} → [SizeOf J] → RingCat.Colimits.Prequotient F → ℕ |
ContinuousLinearMap.continuousConstSMul | Mathlib.Topology.Algebra.Module.StrongTopology | ∀ {𝕜₁ : Type u_1} {𝕜₂ : Type u_2} [inst : NormedField 𝕜₁] [inst_1 : NormedField 𝕜₂] {σ : 𝕜₁ →+* 𝕜₂} {E : Type u_4}
{F : Type u_5} [inst_2 : AddCommGroup E] [inst_3 : Module 𝕜₁ E] [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜₂ F]
[inst_6 : TopologicalSpace E] {M : Type u_7} [inst_7 : Monoid M] [inst_8 : DistribMulAction M F]
[inst_9 : SMulCommClass 𝕜₂ M F] [inst_10 : TopologicalSpace F] [inst_11 : IsTopologicalAddGroup F]
[inst_12 : ContinuousConstSMul M F], ContinuousConstSMul M (E →SL[σ] F) |
LieIdeal.map_sup_ker_eq_map | Mathlib.Algebra.Lie.Ideal | ∀ {R : Type u} {L : Type v} {L' : Type w₂} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieRing L']
[inst_3 : LieAlgebra R L'] [inst_4 : LieAlgebra R L] {f : L →ₗ⁅R⁆ L'} {I : LieIdeal R L},
LieIdeal.map f (I ⊔ f.ker) = LieIdeal.map f I |
SimpleGraph.Copy.isoSubgraphMap._simp_4 | Mathlib.Combinatorics.SimpleGraph.Copy | ∀ {α : Sort u_1}, (∀ (a : α), True) = True |
Lean.Lsp.instHashableResolvableCompletionItemData.hash | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.ResolvableCompletionItemData → UInt64 |
Lean.Compiler.LCNF.LambdaLifting.Context.allowEtaContraction | Lean.Compiler.LCNF.LambdaLifting | Lean.Compiler.LCNF.LambdaLifting.Context → Bool |
MeasureTheory.ofReal_setAverage | Mathlib.MeasureTheory.Integral.Average | ∀ {α : Type u_1} {m0 : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s : Set α} {f : α → ℝ},
MeasureTheory.IntegrableOn f s μ →
0 ≤ᵐ[μ.restrict s] f → ENNReal.ofReal (⨍ (x : α) in s, f x ∂μ) = (∫⁻ (x : α) in s, ENNReal.ofReal (f x) ∂μ) / μ s |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.