name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Multiset.count_sum' | Mathlib.Algebra.BigOperators.Group.Finset.Defs | ∀ {ι : Type u_1} {α : Type u_6} [inst : DecidableEq α] {s : Finset ι} {a : α} {f : ι → Multiset α},
Multiset.count a (∑ x ∈ s, f x) = ∑ x ∈ s, Multiset.count a (f x) | true |
Set.Ioo_subset_Iio_self | Mathlib.Order.Interval.Set.Basic | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ioo a b ⊆ Set.Iio b | true |
NonAssocCommSemiring.natCast._inherited_default | Mathlib.Algebra.Ring.Defs | {α : Type u} → (α → α → α) → α → α → ℕ → α | false |
Int64.toISize_ofNat | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (OfNat.ofNat n).toISize = OfNat.ofNat n | true |
ValuationSubring.unitsModPrincipalUnitsEquivResidueFieldUnits._proof_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u_1} [inst : Field K] (A : ValuationSubring K),
Subgroup.comap A.unitGroup.subtype A.principalUnitGroup = A.unitGroupToResidueFieldUnits.ker | false |
Int32.one_mul | Init.Data.SInt.Lemmas | ∀ (a : Int32), 1 * a = a | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.DerivedValInfo.rec | Lean.Compiler.LCNF.ExplicitRC | {motive : Lean.Compiler.LCNF.DerivedValInfo✝ → Sort u} →
((parent? : Option Lean.FVarId) →
(children : Lean.FVarIdHashSet) → motive { parent? := parent?, children := children }) →
(t : Lean.Compiler.LCNF.DerivedValInfo✝¹) → motive t | false |
Filter.Realizer.comap._proof_1 | Mathlib.Data.Analysis.Filter | ∀ {α : Type u_3} {β : Type u_1} (m : α → β) {f : Filter β} (F : f.Realizer) (x x_1 : F.σ),
m ⁻¹' F.F.f (F.F.inf x x_1) ⊆ m ⁻¹' F.F.f x | false |
CategoryTheory.SmallObject.SuccStruct.extendToSucc.map._proof_6 | Mathlib.CategoryTheory.SmallObject.Iteration.ExtendToSucc | ∀ {J : Type u_1} [inst : LinearOrder J] [inst_1 : SuccOrder J] {j : J} (i₂ : J) (h₁ : i₂ ≤ j), ↑⟨i₂, h₁⟩ ≤ Order.succ j | false |
Batteries.BinomialHeap.Imp.Heap.foldM._unary | Batteries.Data.BinomialHeap.Basic | {m : Type u_1 → Type u_2} →
{α : Type u_3} →
{β : Type u_1} → [Monad m] → (α → α → Bool) → (β → α → m β) → (_ : Batteries.BinomialHeap.Imp.Heap α) ×' β → m β | false |
_private.Init.Data.Fin.Lemmas.0.Fin.reverseInduction_castSucc_aux._proof_1_4 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (j : ℕ) (i : Fin n), ↑i < j + 1 → ¬↑i = j → ¬↑i < j → False | false |
Subbimodule.toSubmodule._proof_1 | Mathlib.Algebra.Module.Bimodule | ∀ {R : Type u_4} {A : Type u_3} {B : Type u_2} {M : Type u_1} [inst : CommSemiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Semiring A] [inst_4 : Semiring B] [inst_5 : Module A M] [inst_6 : Module B M]
[inst_7 : Algebra R A] [inst_8 : Algebra R B] [inst_9 : IsScalarTower R A M] [inst_10 : IsSca... | false |
_private.Mathlib.Order.LatticeIntervals.0.Set.Iic.disjoint_iff._simp_1_1 | Mathlib.Order.LatticeIntervals | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) | false |
Pell.x_sub_y_dvd_pow | Mathlib.NumberTheory.PellMatiyasevic | ∀ {a : ℕ} (a1 : 1 < a) (y n : ℕ), 2 * ↑a * ↑y - ↑y * ↑y - 1 ∣ Pell.yz a1 n * (↑a - ↑y) + ↑(y ^ n) - Pell.xz a1 n | true |
Std.DTreeMap.Internal.Impl.link!._unary.induct_unfolding | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k)
(motive :
(_ : Std.DTreeMap.Internal.Impl α β) ×' Std.DTreeMap.Internal.Impl α β → Std.DTreeMap.Internal.Impl α β → Prop),
(∀ (r : Std.DTreeMap.Internal.Impl α β),
motive ⟨Std.DTreeMap.Internal.Impl.leaf, r⟩ (Std.DTreeMap.Internal.Impl.insertMin! k v r)) →... | false |
_private.Mathlib.Geometry.Euclidean.Incenter.0.Affine.Simplex.ExcenterExists.touchpoint_ne_point._simp_1_8 | Mathlib.Geometry.Euclidean.Incenter | ∀ {G₀ : Type u_2} [inst : GroupWithZero G₀] {a : G₀}, (a⁻¹ = 0) = (a = 0) | false |
Lean.pp.analyze.trustOfNat | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | Lean.Option Bool | true |
Std.Ric.le_upper_of_mem | Init.Data.Range.Polymorphic.Basic | ∀ {α : Type u} {r : Std.Ric α} {a : α} [inst : LE α] [LT α], a ∈ r → a ≤ r.upper | true |
IsSeparatedMap.pullback | Mathlib.Topology.SeparatedMap | ∀ {X : Type u_1} {Y : Sort u_2} {A : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace A] {f : X → Y},
IsSeparatedMap f → ∀ (g : A → Y), IsSeparatedMap Function.Pullback.snd | true |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion._sparseCasesOn_1 | Lean.Meta.LazyDiscrTree | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
UniformOnFun.instPseudoEMetricSpace._proof_4 | Mathlib.Topology.MetricSpace.UniformConvergence | ∀ {α : Type u_2} {β : Type u_1} {𝔖 : Set (Set α)} [inst : PseudoEMetricSpace β] [inst_1 : Finite ↑𝔖]
(f₁ f₂ f₃ : UniformOnFun α β 𝔖), edist f₁ f₃ ≤ edist f₁ f₂ + edist f₂ f₃ | false |
Polynomial.comp.eq_1 | Mathlib.Algebra.Polynomial.Eval.Defs | ∀ {R : Type u} [inst : Semiring R] (p q : Polynomial R), p.comp q = Polynomial.eval₂ Polynomial.C q p | true |
Lean.mkAndN._sunfold | Lean.Expr | List Lean.Expr → Lean.Expr | false |
Int8.toInt.eq_1 | Init.Data.SInt.Lemmas | ∀ (i : Int8), i.toInt = i.toBitVec.toInt | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.IsAdmissible.cons._proof_1_2 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ {m a : ℕ}, a ≤ m → SimplexCategoryGenRel.IsAdmissible m [a] | false |
CategoryTheory.ShortComplex.rightHomology_ext | 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] {A : C} (f₁ f₂ : A ⟶ S.rightHomology),
CategoryTheory.CategoryStruct.comp f₁ S.rightHomologyι = CategoryTheory.CategoryStruct.comp f₂ S... | true |
seqCompactSpace_iff | Mathlib.Topology.Defs.Sequences | ∀ (X : Type u_1) [inst : TopologicalSpace X], SeqCompactSpace X ↔ IsSeqCompact Set.univ | true |
Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusion | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | {P : Sort u} →
{t t' : Lean.Meta.Grind.Arith.CommRing.DiseqCnstr} →
t = t' → Lean.Meta.Grind.Arith.CommRing.DiseqCnstr.noConfusionType P t t' | false |
Lean.JsonRpc.instInhabitedMessageDirection | Lean.Data.JsonRpc | Inhabited Lean.JsonRpc.MessageDirection | true |
Real.HolderConjugate.div_conj_eq_sub_one | Mathlib.Data.Real.ConjExponents | ∀ {p q : ℝ}, p.HolderConjugate q → p / q = p - 1 | true |
IntermediateField.relrank_dvd_of_le_left | Mathlib.FieldTheory.Relrank | ∀ {F : Type u} {E : Type v} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {A B : IntermediateField F E}
(C : IntermediateField F E), A ≤ B → B.relrank C ∣ A.relrank C | true |
AffineMap.pi_ext_nonempty | Mathlib.LinearAlgebra.AffineSpace.AffineMap | ∀ {k : Type u_2} {V2 : Type u_5} {P2 : Type u_6} [inst : Ring k] [inst_1 : AddCommGroup V2] [inst_2 : AddTorsor V2 P2]
[inst_3 : Module k V2] {ι : Type u_9} {φv : ι → Type u_10} [inst_4 : (i : ι) → AddCommGroup (φv i)]
[inst_5 : (i : ι) → Module k (φv i)] [Finite ι] [inst_7 : DecidableEq ι] {f g : ((i : ι) → φv i) ... | true |
Std.DHashMap.Raw.Const.equiv_of_beq | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m₁ m₂ : Std.DHashMap.Raw α fun x => β} [LawfulBEq α]
[inst_3 : BEq β] [LawfulBEq β], m₁.WF → m₂.WF → Std.DHashMap.Raw.Const.beq m₁ m₂ = true → m₁.Equiv m₂ | true |
RootPairing.rec | Mathlib.LinearAlgebra.RootSystem.Defs | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
{N : Type u_4} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R N] →
{motive : RootPairing ι R M N → Sort... | false |
MeasurableEquiv.prodCongr.eq_1 | Mathlib.MeasureTheory.Measure.Haar.InnerProductSpace | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {δ : Type u_4} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
[inst_2 : MeasurableSpace γ] [inst_3 : MeasurableSpace δ] (ab : α ≃ᵐ β) (cd : γ ≃ᵐ δ),
ab.prodCongr cd = { toEquiv := ab.prodCongr cd.toEquiv, measurable_toFun := ⋯, measurable_invFun := ⋯ } | true |
RingCon.instCompleteLattice._proof_2 | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_1} [inst : Add R] [inst_1 : Mul R] (c d : RingCon R) {w x y z : R},
(c.toSetoid ⊓ d.toSetoid) w x →
(c.toSetoid ⊓ d.toSetoid) y z → c.toSetoid (w * y) (x * z) ∧ d.toSetoid (w * y) (x * z) | false |
SSet.IsStrictSegal.mk | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | ∀ {X : SSet}, (∀ (n : ℕ), Function.Bijective (X.spine n)) → X.IsStrictSegal | true |
SSet.StrictSegalCore.concat | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} →
{n : ℕ} →
X.StrictSegalCore n →
(x : X.obj (Opposite.op (SimplexCategory.mk 1))) →
(s : X.obj (Opposite.op (SimplexCategory.mk n))) →
CategoryTheory.SimplicialObject.δ X 0 x = X.map ((SimplexCategory.mk 0).const (SimplexCategory.mk n) 0).op s →
X.obj (Opposite.op (... | true |
Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context.rec | Lean.PrettyPrinter.Delaborator.TopDownAnalyze | {motive : Lean.PrettyPrinter.Delaborator.TopDownAnalyze.Context → Sort u} →
((knowsType knowsLevel inBottomUp parentIsApp : Bool) →
(subExpr : Lean.SubExpr) →
motive
{ knowsType := knowsType, knowsLevel := knowsLevel, inBottomUp := inBottomUp, parentIsApp := parentIsApp,
subExpr :=... | false |
_private.Mathlib.FieldTheory.KrullTopology.0.IntermediateField.map_fixingSubgroup._simp_1_1 | Mathlib.FieldTheory.KrullTopology | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {K : Subgroup N} {f : G →* N} {x : G},
(x ∈ Subgroup.comap f K) = (f x ∈ K) | false |
Aesop.Nanos.instDecidableRelLt | Aesop.Nanos | DecidableRel fun x1 x2 => x1 < x2 | true |
one_add_mul_le_pow' | Mathlib.Algebra.Order.Ring.Pow | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] {a : R},
0 ≤ a * a → 0 ≤ (1 + a) * (1 + a) → 0 ≤ 2 + a → ∀ (n : ℕ), 1 + ↑n * a ≤ (1 + a) ^ n | true |
Equiv.boolEquivPUnitSumPUnit._proof_1 | Mathlib.Logic.Equiv.Sum | ∀ (b : Bool),
Sum.elim (fun x => false) (fun x => true) ((fun b => Bool.casesOn b (Sum.inl PUnit.unit) (Sum.inr PUnit.unit)) b) = b | false |
Antivary.of_inv_right | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : CommGroup β] [inst_2 : PartialOrder β]
[IsOrderedMonoid β] {f : ι → α} {g : ι → β}, Antivary f g⁻¹ → Monovary f g | true |
CategoryTheory.PreservesPullbacksOfInclusions.rec | Mathlib.CategoryTheory.Extensive | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{D : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
{F : CategoryTheory.Functor C D} →
[inst_2 : CategoryTheory.Limits.HasBinaryCoproducts C] →
{motive : CategoryTheory.PreservesPullbacksOfInclusion... | false |
_private.Mathlib.Analysis.Convex.Between.0.sbtw_neg_iff._simp_1_1 | Mathlib.Analysis.Convex.Between | ∀ {G : Type u_1} [inst : SubNegMonoid G] (a : G), -a = 0 - a | false |
RatFunc.liftRingHom_ofFractionRing_algebraMap | Mathlib.FieldTheory.RatFunc.Basic | ∀ {L : Type u_2} {R : Type u_3} [inst : Field L] [inst_1 : CommRing R] (φ : Polynomial R →+* L)
(hφ : nonZeroDivisors (Polynomial R) ≤ Submonoid.comap φ (nonZeroDivisors L)) (x : Polynomial R),
(RatFunc.liftRingHom φ hφ) { toFractionRing := (algebraMap (Polynomial R) (FractionRing (Polynomial R))) x } = φ x | true |
Std.Sat.AIG.mkGateCached.go._proof_1 | Std.Sat.AIG.Cached | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] (decls : Array (Std.Sat.AIG.Decl α))
(cache : Std.Sat.AIG.Cache α decls) (hdag : Std.Sat.AIG.IsDAG α decls) (hzero : 0 < decls.size)
(hconst : decls[0] = Std.Sat.AIG.Decl.false)
(input : { decls := decls, cache := cache, hdag := hdag, hzero := hzero, hcons... | false |
List.card_toFinset | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} [inst : DecidableEq α] (l : List α), l.toFinset.card = l.dedup.length | true |
WittVector.IsocrystalHom._sizeOf_1 | Mathlib.RingTheory.WittVector.Isocrystal | {p : ℕ} →
{inst : Fact (Nat.Prime p)} →
{k : Type u_1} →
{inst_1 : CommRing k} →
{inst_2 : CharP k p} →
{inst_3 : PerfectRing k p} →
{V : Type u_2} →
{inst_4 : AddCommGroup V} →
{inst_5 : WittVector.Isocrystal p k V} →
{V₂ : Type ... | false |
Polynomial.Monic.eq_one_of_isUnit | Mathlib.Algebra.Polynomial.Monic | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R}, p.Monic → IsUnit p → p = 1 | true |
Matroid.emptyOn_isBase_iff._simp_1 | Mathlib.Combinatorics.Matroid.Constructions | ∀ {α : Type u_1} {B : Set α}, (Matroid.emptyOn α).IsBase B = (B = ∅) | false |
Lean.Meta.Grind.Arith.CommRing.EqCnstr.simplify | Lean.Meta.Tactic.Grind.Arith.CommRing.EqCnstr | Lean.Meta.Grind.Arith.CommRing.EqCnstr → Lean.Meta.Grind.Arith.CommRing.RingM Lean.Meta.Grind.Arith.CommRing.EqCnstr | true |
cfc_star_id | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : MetricSpace R]
[inst_3 : IsTopologicalSemiring R] [inst_4 : ContinuousStar R] [inst_5 : TopologicalSpace A] [inst_6 : Ring A]
[inst_7 : StarRing A] [inst_8 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R ... | true |
_private.Mathlib.Order.RelSeries.0.RelSeries.append_assoc._simp_1_1 | Mathlib.Order.RelSeries | ∀ {m k n : ℕ}, (m + n = k + n) = (m = k) | false |
Function.Surjective.distribMulActionLeft | Mathlib.Algebra.GroupWithZero.Action.End | {R : Type u_6} →
{S : Type u_7} →
{M : Type u_8} →
[inst : Monoid R] →
[inst_1 : AddMonoid M] →
[inst_2 : DistribMulAction R M] →
[inst_3 : Monoid S] →
[inst_4 : SMul S M] →
(f : R →* S) → Function.Surjective ⇑f → (∀ (c : R) (x : M), f c • x = c • ... | true |
CategoryTheory.StructuredArrow.map₂IsoPreEquivalenceInverseCompProj._proof_2 | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_6}
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] {E : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} E]
{T : CategoryTheory.Functor C D} {S : CategoryTheory.Functor D E} {T' : CategoryTheory.Functor C E} (d : D) (e : E)
(u : e ⟶ ... | false |
WithTop.toDual_symm | Mathlib.Order.WithBot | ∀ {α : Type u_1}, WithTop.toDual.symm = WithBot.ofDual | true |
StarSubalgebra.topologicalClosure._proof_2 | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_2} {A : Type u_1} [inst : CommSemiring R] [inst_1 : StarRing R] [inst_2 : TopologicalSpace A]
[inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A] [inst_6 : StarModule R A]
[inst_7 : IsSemitopologicalSemiring A] (s : StarSubalgebra R A), 1 ∈ s.topologicalClosure.carrier | false |
Digraph.mk.sizeOf_spec | Mathlib.Combinatorics.Digraph.Basic | ∀ {V : Type u_1} [inst : SizeOf V] (Adj : V → V → Prop), sizeOf { Adj := Adj } = 1 | true |
CategoryTheory.ShiftMkCore.assoc_hom_app._autoParam | Mathlib.CategoryTheory.Shift.Basic | Lean.Syntax | false |
SMulPosReflectLE.lift | Mathlib.Algebra.Order.Module.Defs | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : Preorder γ]
[inst_3 : SMul α β] [inst_4 : SMul α γ] (f : β → γ) [inst_5 : Zero β] [inst_6 : Zero γ] [SMulPosReflectLE α γ],
(∀ {b₁ b₂ : β}, f b₁ ≤ f b₂ ↔ b₁ ≤ b₂) → (∀ (a : α) (b : β), f (a • b) = a • f b) → f 0 = 0 →... | true |
Nat.smallSchroder | Mathlib.Combinatorics.Enumerative.Schroder | ℕ → ℕ | true |
CategoryTheory.prod.leftUnitor_isEquivalence | Mathlib.CategoryTheory.Products.Unitor | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C], (CategoryTheory.prod.leftUnitor C).IsEquivalence | true |
εNFA.ctorIdx | Mathlib.Computability.EpsilonNFA | {α : Type u} → {σ : Type v} → εNFA α σ → ℕ | false |
DirectSum.decompose_one | Mathlib.RingTheory.GradedAlgebra.Basic | ∀ {ι : Type u_1} {A : Type u_3} {σ : Type u_4} [inst : DecidableEq ι] [inst_1 : AddMonoid ι] [inst_2 : Semiring A]
[inst_3 : SetLike σ A] [inst_4 : AddSubmonoidClass σ A] (𝒜 : ι → σ) [inst_5 : GradedRing 𝒜],
(DirectSum.decompose 𝒜) 1 = 1 | true |
Std.TreeMap.Raw.contains_map | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {γ : Type w} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [Std.TransCmp cmp]
{f : α → β → γ} {k : α}, t.WF → (Std.TreeMap.Raw.map f t).contains k = t.contains k | true |
Lean.Meta.RecursorUnivLevelPos.ctorElim | Lean.Meta.RecursorInfo | {motive : Lean.Meta.RecursorUnivLevelPos → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.RecursorUnivLevelPos) →
ctorIdx = t.ctorIdx → Lean.Meta.RecursorUnivLevelPos.ctorElimType ctorIdx → motive t | false |
Associated.dvd_iff_dvd_left | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : Monoid M] {a b c : M}, Associated a b → (a ∣ c ↔ b ∣ c) | true |
hasStrictFDerivAt_zero | Mathlib.Analysis.Calculus.FDeriv.Const | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : AddCommGroup E] [inst_2 : Module 𝕜 E]
[inst_3 : TopologicalSpace E] {F : Type u_3} [inst_4 : AddCommGroup F] [inst_5 : Module 𝕜 F]
[inst_6 : TopologicalSpace F] (x : E), HasStrictFDerivAt 0 0 x | true |
_private.Std.Time.Format.Basic.0.Std.Time.GenericFormat.DateBuilder.m._default | Std.Time.Format.Basic | Option Std.Time.Minute.Ordinal | false |
_private.Mathlib.Order.Interval.Set.LinearOrder.0.Set.Ioc_union_Ioc_union_Ioc_cycle._proof_1_1 | Mathlib.Order.Interval.Set.LinearOrder | ∀ {α : Type u_1} [inst : LinearOrder α] {a b c : α},
Set.Ioc a b ∪ Set.Ioc b c ∪ Set.Ioc c a = Set.Ioc (min a (min b c)) (max a (max b c)) | false |
Lean.Lsp.instToJsonDocumentChange.match_1 | Lean.Data.Lsp.Basic | (motive : Lean.Lsp.DocumentChange → Sort u_1) →
(x : Lean.Lsp.DocumentChange) →
((x : Lean.Lsp.CreateFile) → motive (Lean.Lsp.DocumentChange.create x)) →
((x : Lean.Lsp.RenameFile) → motive (Lean.Lsp.DocumentChange.rename x)) →
((x : Lean.Lsp.DeleteFile) → motive (Lean.Lsp.DocumentChange.delete x)) ... | false |
Booleanisation.instSemilatticeInf._proof_3 | Mathlib.Order.Booleanisation | ∀ {α : Type u_1} [inst : GeneralizedBooleanAlgebra α] (x x_1 x_2 : Booleanisation α), x ≤ x_1 → x ≤ x_2 → x ≤ x_1 ⊓ x_2 | false |
Lean.AxiomVal.casesOn | Lean.Declaration | {motive : Lean.AxiomVal → Sort u} →
(t : Lean.AxiomVal) →
((toConstantVal : Lean.ConstantVal) →
(isUnsafe : Bool) → motive { toConstantVal := toConstantVal, isUnsafe := isUnsafe }) →
motive t | false |
Monoid.CoprodI.Word.consRecOn._proof_3 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (m : (i : ι) × M i) (w : List ((i : ι) × M i))
(h1 : ∀ l ∈ m :: w, l.snd ≠ 1) (h2 : List.IsChain (fun l l' => l.fst ≠ l'.fst) (m :: w)),
{ toList := w, ne_one := ⋯, chain_ne := ⋯ }.fstIdx ≠ some m.fst | false |
ChainComplex.toSingle₀Equiv._proof_6 | Mathlib.Algebra.Homology.Single | ∀ {V : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} V] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms V]
[inst_2 : CategoryTheory.Limits.HasZeroObject V] (C : ChainComplex V ℕ) (X : V)
(φ : C ⟶ (ChainComplex.single₀ V).obj X),
(fun f => HomologicalComplex.mkHomToSingle ↑f ⋯) ((fun φ => ⟨φ.f 0, ⋯⟩) φ) = ... | false |
_private.Std.Sat.CNF.RelabelFin.0.Std.Sat.CNF.Clause.of_maxLiteral_eq_some._simp_1_3 | Std.Sat.CNF.RelabelFin | ∀ {α : Type u_1} {β : Type u_2} {b : β} {f : α → β} {l : List α}, (b ∈ List.map f l) = ∃ a ∈ l, f a = b | false |
CategoryTheory.Quiv.equivOfIso._proof_2 | Mathlib.CategoryTheory.Category.Quiv | ∀ {V W : CategoryTheory.Quiv} (e : V ≅ W) (X : ↑W),
(CategoryTheory.CategoryStruct.comp e.inv e.hom).obj X = (CategoryTheory.CategoryStruct.id W).obj X | false |
Irrational.of_pow | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ} (n : ℕ), Irrational (x ^ n) → Irrational x | true |
Matrix.frobenius_norm_replicateCol | Mathlib.Analysis.Matrix.Normed | ∀ {n : Type u_4} {α : Type u_5} {ι : Type u_7} [inst : Fintype n] [inst_1 : Unique ι]
[inst_2 : SeminormedAddCommGroup α] (v : n → α), ‖Matrix.replicateCol ι v‖ = ‖WithLp.toLp 2 v‖ | true |
Algebra.leftMulMatrix_complex | Mathlib.RingTheory.Complex | ∀ (z : ℂ), (Algebra.leftMulMatrix Complex.basisOneI) z = !![z.re, -z.im; z.im, z.re] | true |
NumberField.InfinitePlace.mult_isComplex | Mathlib.NumberTheory.NumberField.InfinitePlace.Basic | ∀ {K : Type u_1} [inst : Field K] (w : { w // w.IsComplex }), (↑w).mult = 2 | true |
Std.HashSet.contains_toList | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k : α},
m.toList.contains k = m.contains k | true |
_private.Mathlib.Topology.Baire.Lemmas.0.dense_of_mem_residual.match_1_1 | Mathlib.Topology.Baire.Lemmas | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} (motive : (∃ t ⊆ s, IsGδ t ∧ Dense t) → Prop)
(x : ∃ t ⊆ s, IsGδ t ∧ Dense t), (∀ (w : Set X) (hts : w ⊆ s) (left : IsGδ w) (hd : Dense w), motive ⋯) → motive x | false |
String.Pos.Raw.isValidUTF8_extract_iff | Init.Data.String.Basic | ∀ {s : String} (p₁ p₂ : String.Pos.Raw),
p₁ ≤ p₂ →
p₂ ≤ s.rawEndPos →
((s.toByteArray.extract p₁.byteIdx p₂.byteIdx).IsValidUTF8 ↔
p₁ = p₂ ∨ String.Pos.Raw.IsValid s p₁ ∧ String.Pos.Raw.IsValid s p₂) | true |
MeasureTheory.Measure.LebesgueDecomposition.zero_mem_measurableLE | Mathlib.MeasureTheory.Measure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ ν : MeasureTheory.Measure α},
0 ∈ MeasureTheory.Measure.LebesgueDecomposition.measurableLE μ ν | true |
_private.Mathlib.Tactic.Translate.TagUnfoldBoundary.0.Mathlib.Tactic.Translate.CastKind | Mathlib.Tactic.Translate.TagUnfoldBoundary | Type | true |
MvPolynomial.homEquiv._proof_1 | Mathlib.Algebra.MvPolynomial.CommRing | ∀ {S : Type u_1} {σ : Type u_2} [inst : CommRing S] (f : σ → S) (x : σ),
(fun f => ⇑f ∘ MvPolynomial.X) ((fun f => MvPolynomial.eval₂Hom (Int.castRingHom S) f) f) x = f x | false |
LawfulMonadStateOf.get_bind_map_set | Batteries.Control.LawfulMonadState | ∀ {σ : Type u_1} {m : Type u_1 → Type u_2} [inst : Monad m] [inst_1 : MonadStateOf σ m] [LawfulMonadStateOf σ m]
{α : Type u_1} (f : σ → PUnit.{u_1 + 1} → α),
(do
let s ← get
f s <$> set s) =
do
let __do_lift ← get
pure (f __do_lift PUnit.unit) | true |
ergodic_vadd_of_denseRange_nsmul | Mathlib.Dynamics.Ergodic.Action.OfMinimal | ∀ {X : Type u_2} [inst : TopologicalSpace X] [R1Space X] [inst_2 : MeasurableSpace X] [BorelSpace X] {M : Type u_3}
[inst_4 : AddMonoid M] [inst_5 : TopologicalSpace M] [inst_6 : AddAction M X] [ContinuousVAdd M X] {g : M},
(DenseRange fun x => x • g) →
∀ (μ : MeasureTheory.Measure X) [MeasureTheory.IsFiniteMea... | true |
FiniteField.frobeniusAlgEquivOfAlgebraic | Mathlib.FieldTheory.Finite.Basic | (K : Type u_1) →
[inst : Field K] →
[Fintype K] → (L : Type u_3) → [inst_2 : Field L] → [inst_3 : Algebra K L] → [Algebra.IsAlgebraic K L] → Gal(L/K) | true |
List.rtakeWhile_concat | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α) (x : α),
List.rtakeWhile p (l ++ [x]) = if p x = true then List.rtakeWhile p l ++ [x] else [] | true |
Module.Basis.ofIsCoprimeDifferentIdeal | Mathlib.RingTheory.DedekindDomain.LinearDisjoint | (A : Type u_1) →
(B : Type u_2) →
{K : Type u_3} →
{L : Type u_4} →
[inst : CommRing A] →
[inst_1 : Field K] →
[inst_2 : Algebra A K] →
[IsFractionRing A K] →
[inst_4 : CommRing B] →
[inst_5 : Field L] →
[inst_... | true |
CategoryTheory.MonoidalCategory.DayFunctor.equiv._proof_1 | Mathlib.CategoryTheory.Monoidal.DayConvolution.DayFunctor | ∀ (C : Type u_3) [inst : CategoryTheory.Category.{u_1, u_3} C] (V : Type u_4)
[inst_1 : CategoryTheory.Category.{u_2, u_4} V] [inst_2 : CategoryTheory.MonoidalCategory C]
[inst_3 : CategoryTheory.MonoidalCategory V] (X : CategoryTheory.MonoidalCategory.DayFunctor C V),
(CategoryTheory.CategoryStruct.id X).natTran... | false |
OreLocalization.instMonoidWithZero._proof_2 | Mathlib.RingTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : MonoidWithZero R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S]
(x : OreLocalization S R), x * 0 = 0 | false |
Lean.Elab.HeaderProcessedSnapshot.mk.sizeOf_spec | Lean.Elab.DefView | ∀ (toSnapshot : Lean.Language.Snapshot) (view : Lean.Elab.DefViewElabHeaderData) (state : Lean.Elab.Term.SavedState)
(tacStx? : Option Lean.Syntax) (tacSnap? : Option (Lean.Language.SnapshotTask Lean.Elab.Tactic.TacticParsedSnapshot))
(bodyStx : Lean.Syntax) (bodySnap : Lean.Language.SnapshotTask (Option Lean.Elab.... | true |
CliffordAlgebra.foldr'Aux._proof_1 | Mathlib.LinearAlgebra.CliffordAlgebra.Fold | ∀ {R : Type u_1} {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(Q : QuadraticForm R M), SMulCommClass R R (CliffordAlgebra Q) | false |
_private.Init.Data.Dyadic.Basic.0.Rat.toDyadic.match_1.splitter | Init.Data.Dyadic.Basic | (motive : ℤ → Sort u_1) →
(prec : ℤ) → ((n : ℕ) → motive (Int.ofNat n)) → ((n : ℕ) → motive (Int.negSucc n)) → motive prec | true |
BitVec.reduceDiv | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.DSimproc | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.