name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
_private.Mathlib.Topology.UniformSpace.Equiv.0.UniformEquiv.isUniformInducing._simp_1_1 | Mathlib.Topology.UniformSpace.Equiv | ∀ {α : Type u} [inst : UniformSpace α], IsUniformInducing id = True | false |
IsPrimitiveRoot.adjoinEquivRingOfIntegersOfPrimePow.congr_simp | Mathlib.NumberTheory.NumberField.Cyclotomic.Basic | ∀ {p p_1 : ℕ} (e_p : p = p_1) {k k_1 : ℕ} (e_k : k = k_1) {K : Type u} [inst : Field K] {ζ : K}
[hp : Fact (Nat.Prime p)] [inst_1 : CharZero K] [inst_2 : IsCyclotomicExtension {p ^ k} ℚ K]
(hζ : IsPrimitiveRoot ζ (p ^ k)), hζ.adjoinEquivRingOfIntegersOfPrimePow = ⋯.adjoinEquivRingOfIntegersOfPrimePow | true |
Nat.sub_lt_sub_iff_right | Init.Data.Nat.Lemmas | ∀ {a b c : ℕ}, c ≤ a → (a - c < b - c ↔ a < b) | true |
Computation.destruct_pure | Mathlib.Data.Seq.Computation | ∀ {α : Type u} (a : α), (Computation.pure a).destruct = Sum.inl a | true |
Bicategory.Opposite.unop2_comp | Mathlib.CategoryTheory.Bicategory.Opposites | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b : Bᵒᵖ} {f g h : a ⟶ b} (η : f ⟶ g) (θ : g ⟶ h),
(CategoryTheory.CategoryStruct.comp η θ).unop2 = CategoryTheory.CategoryStruct.comp η.unop2 θ.unop2 | true |
eq_of_fin_equiv | Mathlib.LinearAlgebra.InvariantBasisNumber | ∀ (R : Type u) [inst : Semiring R] [InvariantBasisNumber R] {n m : ℕ} (a : (Fin n → R) ≃ₗ[R] Fin m → R), n = m | true |
ContinuousAlgEquiv.continuous_toFun | Mathlib.Topology.Algebra.Algebra.Equiv | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring B] [inst_4 : TopologicalSpace B] [inst_5 : Algebra R A]
[inst_6 : Algebra R B] (self : A ≃A[R] B), Continuous self.toFun | true |
trivialVectorBundleCore._proof_2 | Mathlib.Topology.VectorBundle.Basic | ∀ (F : Type u_1) [inst : NormedAddCommGroup F], IsTopologicalAddGroup F | false |
AlgebraicGeometry.LocallyRingedSpace.stalkMap_congr_assoc | Mathlib.Geometry.RingedSpace.LocallyRingedSpace | ∀ {X Y : AlgebraicGeometry.LocallyRingedSpace} (f g : X ⟶ Y) (hfg : f = g) (x x' : ↑X.toTopCat) (hxx' : x = x')
{Z : CommRingCat} (h : X.presheaf.stalk x' ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.LocallyRingedSpace.Hom.stalkMap f x)
(CategoryTheory.CategoryStruct.comp (X.presheaf.stalkSpeci... | true |
IsArtinianRing.isSemisimpleRing_iff_jacobson | Mathlib.RingTheory.Artinian.Module | ∀ {R : Type u_1} [inst : Ring R] [IsArtinianRing R], IsSemisimpleRing R ↔ Ring.jacobson R = ⊥ | true |
TopologicalSpace.IsCompletelyMetrizableSpace.mk._flat_ctor | Mathlib.Topology.Metrizable.CompletelyMetrizable | ∀ {X : Type u_3} [t : TopologicalSpace X],
(∃ m, PseudoMetricSpace.toUniformSpace.toTopologicalSpace = t ∧ CompleteSpace X) →
TopologicalSpace.IsCompletelyMetrizableSpace X | false |
MeasurableSet.const | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} {m : MeasurableSpace α} (p : Prop), MeasurableSet {_a | p} | true |
CategoryTheory.Injective.enoughInjectives_of_enoughProjectives_op | Mathlib.CategoryTheory.Preadditive.Injective.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [CategoryTheory.EnoughProjectives Cᵒᵖ],
CategoryTheory.EnoughInjectives C | true |
_private.Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms.0.SimplexCategoryGenRel.simplicialInsert.match_1.eq_1 | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.NormalForms | ∀ (motive : List ℕ → Sort u_1) (h_1 : Unit → motive []) (h_2 : (b : ℕ) → (l : List ℕ) → motive (b :: l)),
(match [] with
| [] => h_1 ()
| b :: l => h_2 b l) =
h_1 () | true |
Std.Tactic.BVDecide.BVExpr.bitblast.goCache | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Expr | {w : ℕ} →
(aig : Std.Sat.AIG Std.Tactic.BVDecide.BVBit) →
Std.Tactic.BVDecide.BVExpr w → Std.Tactic.BVDecide.BVExpr.Cache aig → Std.Tactic.BVDecide.BVExpr.Return aig w | true |
PSum.inhabitedLeft | Init.Core | {α : Sort u_1} → {β : Sort u_2} → [Inhabited α] → Inhabited (α ⊕' β) | true |
Std.DTreeMap.Internal.Impl.Const.mem_alter!_self | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {β : Type v} {t : Std.DTreeMap.Internal.Impl α fun x => β} [Std.TransOrd α],
t.WF →
∀ {k : α} {f : Option β → Option β},
k ∈ Std.DTreeMap.Internal.Impl.Const.alter! k f t ↔ (f (Std.DTreeMap.Internal.Impl.Const.get? t k)).isSome = true | true |
Topology.IsGeneratedBy.instPUnit | Mathlib.Topology.Convenient.GeneratedBy | ∀ {ι : Type t} {X : ι → Type u} [inst : (i : ι) → TopologicalSpace (X i)], Topology.IsGeneratedBy X PUnit.{v + 1} | true |
ArchimedeanClass.instCommRingFiniteElement._proof_27 | Mathlib.Algebra.Order.Ring.StandardPart | ∀ (K : Type u_1) [inst : LinearOrder K] [inst_1 : Field K] [inst_2 : IsOrderedRing K],
autoParam (∀ (n : ℕ), ↑(n + 1) = ↑n + 1) AddMonoidWithOne.natCast_succ._autoParam | false |
_private.Std.Time.Zoned.Database.Basic.0.Std.Time.TimeZone.convertTZifV1.match_4 | Std.Time.Zoned.Database.Basic | (motive : Option Std.Time.TimeZone.Transition → Sort u_1) →
(x : Option Std.Time.TimeZone.Transition) →
((result : Std.Time.TimeZone.Transition) → motive (some result)) →
((x : Option Std.Time.TimeZone.Transition) → motive x) → motive x | false |
Nat.toList_roo_eq_append | Init.Data.Range.Polymorphic.NatLemmas | ∀ {m n : ℕ}, m + 1 < n → (m<...n).toList = (m<...n - 1).toList ++ [n - 1] | true |
AlgebraicGeometry.Etale.etale_comp | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {Z : AlgebraicGeometry.Scheme} (g : Y ⟶ Z) [AlgebraicGeometry.Etale f]
[AlgebraicGeometry.Etale g], AlgebraicGeometry.Etale (CategoryTheory.CategoryStruct.comp f g) | true |
CategoryTheory.FreeMonoidalCategory.Hom.comp.sizeOf_spec | Mathlib.CategoryTheory.Monoidal.Free.Basic | ∀ {C : Type u} [inst : SizeOf C] {X Y Z : CategoryTheory.FreeMonoidalCategory C} (f : X.Hom Y) (g : Y.Hom Z),
sizeOf (f.comp g) = 1 + sizeOf X + sizeOf Y + sizeOf Z + sizeOf f + sizeOf g | true |
AlgEquiv.ofInjective_apply | Mathlib.Algebra.Algebra.Subalgebra.Basic | ∀ {R : Type u} {A : Type v} {B : Type w} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Semiring B]
[inst_3 : Algebra R A] [inst_4 : Algebra R B] (f : A →ₐ[R] B) (hf : Function.Injective ⇑f) (x : A),
↑((AlgEquiv.ofInjective f hf) x) = f x | true |
CategoryTheory.Iso.groupIsoToMulEquiv._proof_1 | Mathlib.Algebra.Category.Grp.Basic | ∀ {X Y : GrpCat} (i : X ≅ Y), (GrpCat.Hom.hom i.inv).comp (GrpCat.Hom.hom i.hom) = MonoidHom.id ↑X | false |
_private.Std.Sat.AIG.CNF.0.Std.Sat.AIG.toCNF.projectRightAssign_property | Std.Sat.AIG.CNF | ∀ {assign : ℕ → Bool} {x : ℕ}, Std.Sat.AIG.toCNF.projectRightAssign✝ assign x = assign x | true |
Set.inter_singleton_nonempty | Mathlib.Data.Set.Insert | ∀ {α : Type u_1} {s : Set α} {a : α}, (s ∩ {a}).Nonempty ↔ a ∈ s | true |
Std.DHashMap.Raw.mem_of_mem_insert | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {m : Std.DHashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → ∀ {k a : α} {v : β k}, a ∈ m.insert k v → (k == a) = false → a ∈ m | true |
_private.Mathlib.Data.Finset.Card.0.Finset.two_lt_card._simp_1_2 | Mathlib.Data.Finset.Card | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, b ∧ p x) = (b ∧ ∃ x, p x) | false |
Finset.prod_range_div' | Mathlib.Algebra.BigOperators.Group.Finset.Basic | ∀ {G : Type u_3} [inst : CommGroup G] (f : ℕ → G) (n : ℕ), ∏ i ∈ Finset.range n, f i / f (i + 1) = f 0 / f n | true |
FirstOrder.Language.exists_cg_is_age_of | Mathlib.ModelTheory.Fraisse | ∀ {L : FirstOrder.Language} {K : Set (CategoryTheory.Bundled L.Structure)},
K.Nonempty →
(Quotient.mk' '' K).Countable →
(∀ M ∈ K, FirstOrder.Language.Structure.FG L ↑M) →
FirstOrder.Language.Hereditary K →
FirstOrder.Language.JointEmbedding K → ∃ M, FirstOrder.Language.Structure.CG L ↑M ∧... | true |
_private.Lean.Meta.MkIffOfInductiveProp.0.Lean.Meta.List.init.match_1 | Lean.Meta.MkIffOfInductiveProp | {α : Type u_1} →
(motive : List α → Sort u_2) →
(x : List α) →
(Unit → motive []) → ((head : α) → motive [head]) → ((a : α) → (l : List α) → motive (a :: l)) → motive x | false |
SuccOrder.limitRecOn.eq_1 | Mathlib.Order.SuccPred.Limit | ∀ {α : Type u_1} (b : α) {motive : α → Sort u_2} [inst : PartialOrder α] [inst_1 : SuccOrder α]
[inst_2 : WellFoundedLT α] (isMin : (a : α) → IsMin a → motive a)
(succ : (a : α) → ¬IsMax a → motive a → motive (Order.succ a))
(isSuccLimit : (a : α) → Order.IsSuccLimit a → ((b : α) → b < a → motive b) → motive a),
... | true |
Array.extract.eq_1 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (start stop : ℕ),
as.extract start stop =
Array.extract.loop as ((min stop as.size).sub start) start (Array.emptyWithCapacity ((min stop as.size).sub start)) | true |
MvPolynomial.IsPrime.vanishingIdeal_zeroLocus | Mathlib.RingTheory.Nullstellensatz | ∀ {k : Type u_1} {K : Type u_2} [inst : Field k] [inst_1 : Field K] [inst_2 : Algebra k K] {σ : Type u_3}
[IsAlgClosed K] [Finite σ] (P : Ideal (MvPolynomial σ k)) [h : P.IsPrime],
MvPolynomial.vanishingIdeal k (MvPolynomial.zeroLocus K P) = P | true |
FreeAddMonoid.instMembership | Mathlib.Algebra.FreeMonoid.Basic | {α : Type u_1} → Membership α (FreeAddMonoid α) | true |
Lean.Elab.WF.EqnInfo.value | Lean.Elab.PreDefinition.WF.Eqns | Lean.Elab.WF.EqnInfo → Lean.Expr | true |
instDecidableEqOrderedFinpartition.decEq._proof_10 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (a : ℕ) (a_1 : Fin a → ℕ) (a_2 : ∀ (m : Fin a), 0 < a_1 m) (a_3 : (m : Fin a) → Fin (a_1 m) → Fin n)
(a_4 : ∀ (m : Fin a), StrictMono (a_3 m)) (a_5 : StrictMono fun m => a_3 m ⟨a_1 m - 1, ⋯⟩)
(a_6 : Set.univ.PairwiseDisjoint fun m => Set.range (a_3 m)) (a_7 : ∀ (x : Fin n), ∃ m, x ∈ Set.range (a_3 m)),
... | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.ofArray_fold_fn.match_1.eq_2 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (motive : Option (Std.Sat.Literal (Std.Tactic.BVDecide.LRAT.Internal.PosFin n)) → Sort u_1)
(l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) (h_1 : Unit → motive none)
(h_2 : (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n) → motive (some (l, true)))
(h_3 : (l : Std.Tactic.BVDecide.LRAT.Internal.PosFin ... | true |
Lists'.recOfList | Mathlib.SetTheory.Lists | {α : Type u_1} →
{motive : Lists' α true → Sort u_2} →
((l : List (Lists α)) → motive (Lists'.ofList l)) → (l : Lists' α true) → motive l | true |
Condensed.fintypeCatAsCofan | Mathlib.Condensed.Discrete.Colimit | (X : Profinite) → CategoryTheory.Limits.Cofan fun x => Profinite.of PUnit.{u + 1} | true |
Int.cast_natAbs | Mathlib.Algebra.Order.Ring.Cast | ∀ {α : Type u_1} [inst : AddGroupWithOne α] (n : ℤ), ↑n.natAbs = ↑|n| | true |
Aesop.IndexMatchLocation.hyp.sizeOf_spec | Aesop.Index.Basic | ∀ (ldecl : Lean.LocalDecl), sizeOf (Aesop.IndexMatchLocation.hyp ldecl) = 1 + sizeOf ldecl | true |
Bipointed.hasForget._proof_6 | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X.HomSubtype Y), ↑f X.toProd.1 = Y.toProd.1 | false |
Ordinal.sInf_compl_lt_lift_ord_succ | Mathlib.SetTheory.Ordinal.Family | ∀ {ι : Type u} (f : ι → Ordinal.{max u v}), sInf (Set.range f)ᶜ < Ordinal.lift.{v, u} (Order.succ (Cardinal.mk ι)).ord | true |
HurwitzKernelBounds.isBigO_exp_neg_mul_of_le | Mathlib.NumberTheory.ModularForms.JacobiTheta.Bounds | ∀ {c d : ℝ}, c ≤ d → (fun t => Real.exp (-d * t)) =O[Filter.atTop] fun t => Real.exp (-c * t) | true |
Multiset.ext | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} [inst : DecidableEq α] {s t : Multiset α}, s = t ↔ ∀ (a : α), Multiset.count a s = Multiset.count a t | true |
_private.Init.Data.Range.Polymorphic.SInt.0.BitVec.Signed.rotate.eq_1 | Init.Data.Range.Polymorphic.SInt | ∀ {n : ℕ} (x : BitVec n), BitVec.Signed.rotate✝ x = x + BitVec.Signed.intMinSealed✝ n | true |
divisibleByIntOfCharZero._proof_2 | Mathlib.GroupTheory.Divisible | ∀ {𝕜 : Type u_1} [inst : DivisionRing 𝕜] [CharZero 𝕜] {n : ℤ} (q : 𝕜), n ≠ 0 → n • (q / ↑n) = q | false |
ValuationSubring.eq_iff_unitGroup | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {K : Type u} [inst : Field K] {A B : ValuationSubring K}, A = B ↔ A.unitGroup = B.unitGroup | true |
String.Slice.RevByteIterator.instIteratorUInt8OfPure | Init.Data.String.Iterate | {m : Type → Type u_1} → [Pure m] → Std.Iterator String.Slice.RevByteIterator m UInt8 | true |
CardinalInterFilter | Mathlib.Order.Filter.CardinalInter | {α : Type u} → Filter α → Cardinal.{u} → Prop | true |
Submodule.lipschitzWith_orthogonalProjection | Mathlib.Analysis.InnerProductSpace.Projection.Basic | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : InnerProductSpace 𝕜 E]
(K : Submodule 𝕜 E) [inst_3 : K.HasOrthogonalProjection], LipschitzWith 1 ⇑K.orthogonalProjection | true |
String.Slice.RevByteIterator.recOn | Init.Data.String.Iterate | {motive : String.Slice.RevByteIterator → Sort u} →
(t : String.Slice.RevByteIterator) →
((s : String.Slice) →
(offset : String.Pos.Raw) → (hinv : offset ≤ s.rawEndPos) → motive { s := s, offset := offset, hinv := hinv }) →
motive t | false |
_private.Mathlib.LinearAlgebra.RootSystem.Base.0.RootPairing.Base.sub_notMem_range_root._simp_1_1 | Mathlib.LinearAlgebra.RootSystem.Base | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
Algebra.charZero_of_charZero | Mathlib.Algebra.Algebra.Basic | ∀ (R : Type u_1) (A : Type u_2) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] [FaithfulSMul R A]
[CharZero R], CharZero A | true |
MvPolynomial.HomogeneousSubmodule.gradedMonoid | Mathlib.RingTheory.MvPolynomial.Homogeneous | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommSemiring R], SetLike.GradedMonoid (MvPolynomial.homogeneousSubmodule σ R) | true |
EMetric.NonemptyCompacts.isUniformEmbedding_toCloseds | Mathlib.Topology.MetricSpace.Closeds | ∀ {α : Type u_1} [inst : UniformSpace α] [inst_1 : T2Space α],
IsUniformEmbedding TopologicalSpace.NonemptyCompacts.toCloseds | true |
Std.TreeMap.Raw.compare_maxKey?_modify_eq | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] (h : t.WF)
{k : α} {f : β → β} {km kmm : α} (hkm : t.maxKey? = some km),
(t.modify k f).maxKey?.get ⋯ = kmm → cmp kmm km = Ordering.eq | true |
CategoryTheory.uliftYoneda_map_app | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {X Y : C} (f : X ⟶ Y) (X_1 : Cᵒᵖ)
(a : CategoryTheory.uliftFunctor.{w, v₁}.obj ((CategoryTheory.yoneda.obj X).obj X_1)),
(CategoryTheory.uliftYoneda.{w, v₁, u₁}.map f).app X_1 a = { down := CategoryTheory.CategoryStruct.comp a.down f } | true |
_private.Init.Data.Range.Polymorphic.Internal.SignedBitVec.0.BitVec.Signed.ofNat_eq_rotate_ofInt_sub | Init.Data.Range.Polymorphic.Internal.SignedBitVec | ∀ {n k : ℕ}, BitVec.ofNat n k = BitVec.Signed.rotate✝ (BitVec.ofInt n (↑k - ↑(BitVec.Signed.intMinSealed✝ n).toNat)) | true |
_private.Init.Data.Array.Lemmas.0.Array.erase.match_1.eq_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} (as : Array α) (motive : Option (Fin as.size) → Sort u_2) (i : Fin as.size) (h_1 : Unit → motive none)
(h_2 : (i : Fin as.size) → motive (some i)),
(match some i with
| none => h_1 ()
| some i => h_2 i) =
h_2 i | true |
Aesop.GlobalRuleSetMember.name | Aesop.RuleSet.Member | Aesop.GlobalRuleSetMember → Aesop.RuleName | true |
PiTensorProduct.instAlgebra._proof_4 | Mathlib.RingTheory.PiTensorProduct | ∀ {ι : Type u_1} {R' : Type u_4} {R : Type u_2} {A : ι → Type u_3} [inst : CommSemiring R'] [inst_1 : CommSemiring R]
[inst_2 : (i : ι) → Semiring (A i)] [inst_3 : Algebra R' R] [inst_4 : (i : ι) → Algebra R (A i)] (x y : R'),
(x + y) • 1 = x • 1 + y • 1 | false |
_private.Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs.0.SimpleGraph.binomialRandom_singleton._simp_1_2 | Mathlib.Probability.Combinatorics.BinomialRandomGraph.Defs | ∀ {V : Type u} (G : SimpleGraph V), (G.edgeSet ⊆ Sym2.diagSetᶜ) = True | false |
Submodule.reflection | Mathlib.Analysis.InnerProductSpace.Projection.Reflection | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : RCLike 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : InnerProductSpace 𝕜 E] → (K : Submodule 𝕜 E) → [K.HasOrthogonalProjection] → E ≃ₗᵢ[𝕜] E | true |
HomologicalComplex.fromOpcycles_op_cyclesOpIso_inv | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_1} {V : Type u_2} [inst : CategoryTheory.Category.{v_1, u_2} V] {c : ComplexShape ι}
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] (K : HomologicalComplex V c) (i : ι) [inst_2 : K.HasHomology i]
(j : ι), CategoryTheory.CategoryStruct.comp (K.fromOpcycles i j).op (K.cyclesOpIso i).inv = K.op.toCy... | true |
Std.Internal.Parsec.ParseResult | Std.Internal.Parsec.Basic | Type → Type → Type | true |
MeasureTheory.VectorMeasure.rec | Mathlib.MeasureTheory.VectorMeasure.Basic | {α : Type u_3} →
[inst : MeasurableSpace α] →
{M : Type u_4} →
[inst_1 : AddCommMonoid M] →
[inst_2 : TopologicalSpace M] →
{motive : MeasureTheory.VectorMeasure α M → Sort u} →
((measureOf' : Set α → M) →
(empty' : measureOf' ∅ = 0) →
(not_mea... | false |
Tactic.ComputeAsymptotics.Seq.FriendlyOperationClass.comp | Mathlib.Tactic.ComputeAsymptotics.Multiseries.Corecursion | ∀ {α : Type u_1} {γ : Type u_3} {γ' : Type u_4} (F : γ → Stream'.Seq α → Stream'.Seq α) (g : γ' → γ)
[h : Tactic.ComputeAsymptotics.Seq.FriendlyOperationClass F],
Tactic.ComputeAsymptotics.Seq.FriendlyOperationClass fun c => F (g c) | true |
_private.Mathlib.Algebra.Colimit.Ring.0.Ring.DirectLimit.Polynomial.exists_of.match_1_3 | Mathlib.Algebra.Colimit.Ring | ∀ {ι : Type u_1} [inst : Preorder ι] (i₁ i₂ : ι) (motive : (∃ c, i₁ ≤ c ∧ i₂ ≤ c) → Prop) (x : ∃ c, i₁ ≤ c ∧ i₂ ≤ c),
(∀ (i : ι) (h1 : i₁ ≤ i) (h2 : i₂ ≤ i), motive ⋯) → motive x | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.Expr.alphaEqv._sparseCasesOn_13 | Lean.Compiler.IR.Basic | {motive : Lean.IR.Expr → Sort u} →
(t : Lean.IR.Expr) →
((x : Lean.IR.VarId) → motive (Lean.IR.Expr.isShared x)) → (Nat.hasNotBit 4096 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.ShortComplex.homology_π_ι | Mathlib.Algebra.Homology.ShortComplex.Homology | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(S : CategoryTheory.ShortComplex C) [inst_2 : S.HasHomology],
CategoryTheory.CategoryStruct.comp S.homologyπ S.homologyι = CategoryTheory.CategoryStruct.comp S.iCycles S.pOpcycles | true |
Lean.ParserCompiler.Context._sizeOf_1 | Lean.ParserCompiler | {α : Type} → [SizeOf α] → Lean.ParserCompiler.Context α → ℕ | false |
Descriptive.Tree.drop._proof_1 | Mathlib.SetTheory.Descriptive.Tree | ∀ {A : Type u_1} (T : ↥(Descriptive.tree A)) (n : ℕ) (x : ↥T),
List.drop n ↑x ∈ Descriptive.Tree.subAt T ↑(Descriptive.Tree.take n x) | false |
instDecidableEqPSigma.match_5 | Init.Core | {α : Sort u_1} →
{β : α → Sort u_2} →
(motive : PSigma β → PSigma β → Sort u_3) →
(x x_1 : PSigma β) → ((a₁ : α) → (b₁ : β a₁) → (a₂ : α) → (b₂ : β a₂) → motive ⟨a₁, b₁⟩ ⟨a₂, b₂⟩) → motive x x_1 | false |
CategoryTheory.Square.unopFunctor._proof_8 | Mathlib.CategoryTheory.Square | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : (CategoryTheory.Square Cᵒᵖ)ᵒᵖ} (φ : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (Opposite.unop X).unop.f₁₃ φ.unop.τ₃.unop =
CategoryTheory.CategoryStruct.comp φ.unop.τ₄.unop (Opposite.unop Y).unop.f₁₃ | false |
AntitoneOn.Icc | Mathlib.Order.Interval.Set.Monotone | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] {f g : α → β} {s : Set α},
AntitoneOn f s → MonotoneOn g s → MonotoneOn (fun x => Set.Icc (f x) (g x)) s | true |
noMinOrder_iff | Mathlib.Order.Max | ∀ {α : Type u_1} [inst : Preorder α], NoMinOrder α ↔ ∀ (x : α), ¬IsMin x | true |
_private.Lean.Setup.0.Lean.ImportArtifacts.oleanParts.match_1 | Lean.Setup | (motive : Option System.FilePath → Sort u_1) →
(x : Option System.FilePath) →
((pFile : System.FilePath) → motive (some pFile)) → ((x : Option System.FilePath) → motive x) → motive x | false |
Nat.map_add_toArray_ric' | Init.Data.Range.Polymorphic.NatLemmas | ∀ {n k : ℕ}, Array.map (fun x => k + x) (*...=n).toArray = (k...=k + n).toArray | true |
_private.Mathlib.Logic.Denumerable.0.Nat.Subtype.exists_succ._simp_1_2 | Mathlib.Logic.Denumerable | ∀ {α : Type u_1} {p : α → Prop} [inst : DecidablePred p] {a : α} {s : Multiset α},
(a ∈ Multiset.filter p s) = (a ∈ s ∧ p a) | false |
_private.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.congrImplies | Lean.Elab.Tactic.Conv.Congr | Lean.MVarId → Lean.MetaM (List Lean.MVarId) | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (h : Lean.Expr) (x : Int.Linear.Var) (e' : Int.Linear.Expr),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.defnNat h x e') = 1 + sizeOf h + sizeOf x + sizeOf e' | true |
Lean.Grind.CommRing.SimpResult.k₁._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Poly | ℤ | false |
FundamentalGroupoid.punitEquivDiscretePUnit_functor | Mathlib.AlgebraicTopology.FundamentalGroupoid.PUnit | FundamentalGroupoid.punitEquivDiscretePUnit.functor = CategoryTheory.Functor.star (FundamentalGroupoid PUnit.{u + 1}) | true |
GrpCat.Hom.noConfusionType | Mathlib.Algebra.Category.Grp.Basic | Sort u_1 → {A B : GrpCat} → A.Hom B → {A' B' : GrpCat} → A'.Hom B' → Sort u_1 | false |
_private.Init.Data.List.Lemmas.0.List.getElem!_of_getElem?.match_1_1 | Init.Data.List.Lemmas | ∀ {α : Type u_1} {a : α} (motive : (x : List α) → (x_1 : ℕ) → x[x_1]? = some a → Prop) (x : List α) (x_1 : ℕ)
(x_2 : x[x_1]? = some a),
(∀ (_a : α) (tail : List α) (x : (_a :: tail)[0]? = some a), motive (_a :: tail) 0 x) →
(∀ (head : α) (l : List α) (n : ℕ) (e : (head :: l)[n + 1]? = some a), motive (head :: l... | false |
Lean.Meta.Tactic.Cbv.CbvEvalEntry.thm | Lean.Meta.Tactic.Cbv.CbvEvalExt | Lean.Meta.Tactic.Cbv.CbvEvalEntry → Lean.Meta.Sym.Simp.Theorem | true |
CategoryTheory.MonoidalPreadditive.zero_whiskerRight | Mathlib.CategoryTheory.Monoidal.Preadditive | ∀ {C : Type u_1} {inst : CategoryTheory.Category.{v_1, u_1} C} {inst_1 : CategoryTheory.Preadditive C}
{inst_2 : CategoryTheory.MonoidalCategory C} [self : CategoryTheory.MonoidalPreadditive C] {X Y Z : C},
CategoryTheory.MonoidalCategoryStruct.whiskerRight 0 X = 0 | true |
Algebra.Extension.exact_hCotangentι_cotangentComplex | Mathlib.RingTheory.Extension.Cotangent.Basic | ∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S]
{P : Algebra.Extension R S}, Function.Exact ⇑Algebra.Extension.h1Cotangentι ⇑P.cotangentComplex | true |
Filter.Tendsto.arsinh | Mathlib.Analysis.SpecialFunctions.Arsinh | ∀ {α : Type u_1} {l : Filter α} {f : α → ℝ} {a : ℝ},
Filter.Tendsto f l (nhds a) → Filter.Tendsto (fun x => Real.arsinh (f x)) l (nhds (Real.arsinh a)) | true |
CategoryTheory.Limits.Cone.forget._proof_1 | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] (F : CategoryTheory.Functor J C) (X : CategoryTheory.Limits.Cone F),
(CategoryTheory.CategoryStruct.id X).hom = CategoryTheory.CategoryStruct.id X.pt | false |
AddMonCat.instCoeSortType.eq_1 | Mathlib.Algebra.Category.MonCat.Basic | AddMonCat.instCoeSortType = { coe := AddMonCat.carrier } | true |
OptionT.mkLabel | Mathlib.Control.Monad.Cont | {m : Type u → Type v} → [Monad m] → {α β : Type u} → MonadCont.Label (Option α) m β → MonadCont.Label α (OptionT m) β | true |
Subarray.toArray_eq_sliceToArray | Init.Data.Slice.Array.Lemmas | ∀ {α : Type u} {s : Subarray α}, Std.Slice.toArray s = Std.Slice.toArray s | true |
Set.preimage_invFun_of_mem | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} [n : Nonempty α] {f : α → β},
Function.Injective f → ∀ {s : Set α}, Classical.choice n ∈ s → Function.invFun f ⁻¹' s = f '' s ∪ (Set.range f)ᶜ | true |
Monoid.CoprodI.NeWord.of_word | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] (w : Monoid.CoprodI.Word M),
w ≠ Monoid.CoprodI.Word.empty → ∃ i j w', w'.toWord = w | true |
Ordinal.div_add_mod | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ (a b : Ordinal.{u_4}), b * (a / b) + a % b = a | true |
_private.Mathlib.RingTheory.Perfectoid.FontaineTheta.0._aux_Mathlib_RingTheory_Perfectoid_FontaineTheta___delab_app__private_Mathlib_RingTheory_Perfectoid_FontaineTheta_0_term𝔭_1 | Mathlib.RingTheory.Perfectoid.FontaineTheta | Lean.PrettyPrinter.Delaborator.Delab | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.