name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
AlgebraicGeometry.WeaklyEtale | Mathlib.AlgebraicGeometry.Morphisms.WeaklyEtale | {X Y : AlgebraicGeometry.Scheme} → (X ⟶ Y) → Prop | true |
_private.Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable.0.summable_jacobiTheta₂_term_iff._simp_1_2 | Mathlib.NumberTheory.ModularForms.JacobiTheta.TwoVariable | ∀ {β : Type u_2} {G : Type u_4} [inst : TopologicalSpace G] [inst_1 : AddCommGroup G] [IsTopologicalAddGroup G]
[Infinite β] [T2Space G] (a : G), (Summable fun x => a) = (a = 0) | false |
Std.Internal.List.containsKey_insertList_disj_of_containsKey | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l toInsert : List ((a : α) × β a)} {k : α},
Std.Internal.List.containsKey k (Std.Internal.List.insertList l toInsert) =
(Std.Internal.List.containsKey k l || Std.Internal.List.containsKey k toInsert) | true |
left_mem_segment | Mathlib.Analysis.Convex.Segment | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[ZeroLEOneClass 𝕜] [inst_4 : MulActionWithZero 𝕜 E] (x y : E), x ∈ segment 𝕜 x y | true |
CategoryTheory.yonedaMap._proof_2 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_2, u_3} D] (F : CategoryTheory.Functor C D) (X : C) ⦃X_1 Y : Cᵒᵖ⦄ (f : X_1 ⟶ Y),
(CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.obj X).map f) fun f => F.map f) =
CategoryTheory.Categor... | false |
Order.Cofinal.above | Mathlib.Order.Ideal | {P : Type u_1} → [inst : Preorder P] → Order.Cofinal P → P → P | true |
Lean.Meta.Simp.Stats.recOn | Lean.Meta.Tactic.Simp.Types | {motive : Lean.Meta.Simp.Stats → Sort u} →
(t : Lean.Meta.Simp.Stats) →
((usedTheorems : Lean.Meta.Simp.UsedSimps) →
(diag : Lean.Meta.Simp.Diagnostics) → motive { usedTheorems := usedTheorems, diag := diag }) →
motive t | false |
padicValRat.div | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {q r : ℚ}, q ≠ 0 → r ≠ 0 → padicValRat p (q / r) = padicValRat p q - padicValRat p r | true |
Set.mapsTo_univ | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} (f : α → β) (s : Set α), Set.MapsTo f s Set.univ | true |
Subspace.flip_quotDualCoannihilatorToDual_bijective | Mathlib.LinearAlgebra.Dual.Lemmas | ∀ {K : Type u_4} {V : Type u_5} [inst : Field K] [inst_1 : AddCommGroup V] [inst_2 : Module K V]
(W : Subspace K (Module.Dual K V)) [FiniteDimensional K ↥W],
Function.Bijective ⇑(Submodule.quotDualCoannihilatorToDual W).flip | true |
Lean.Elab.Term.CalcStepView.mk.noConfusion | Lean.Elab.Calc | {P : Sort u} →
{ref : Lean.Syntax} →
{term proof : Lean.Term} →
{ref' : Lean.Syntax} →
{term' proof' : Lean.Term} →
{ ref := ref, term := term, proof := proof } = { ref := ref', term := term', proof := proof' } →
(ref = ref' → term = term' → proof = proof' → P) → P | false |
Int.instAdd | Init.Data.Int.Basic | Add ℤ | true |
linarithToGrindRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config | true |
ZLattice.comap_refl | Mathlib.Algebra.Module.ZLattice.Basic | ∀ (K : Type u_1) [inst : NormedField K] {E : Type u_2} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace K E]
(L : Submodule ℤ E), ZLattice.comap K L 1 = L | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.isRflTheoremCore.match_1 | Lean.Meta.Tactic.Simp.SimpTheorems | (motive : Lean.ConstantInfo → Sort u_1) →
(__discr : Lean.ConstantInfo) →
((info : Lean.TheoremVal) → motive (Lean.ConstantInfo.thmInfo info)) →
((x : Lean.ConstantInfo) → motive x) → motive __discr | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_of_contains_erase._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) | false |
Submonoid.map._proof_2 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : MulOneClass N] {F : Type u_3} [inst_2 : FunLike F M N]
[mc : MonoidHomClass F M N] (f : F) (S : Submonoid M), ∃ a ∈ ↑S, f a = 1 | false |
Std.DTreeMap.Raw.self_le_maxKeyD_insertIfNew | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α} {v : β k} {fallback : α}, (cmp k ((t.insertIfNew k v).maxKeyD fallback)).isLE = true | true |
Turing.TM0.Cfg.q | Mathlib.Computability.TuringMachine.PostTuringMachine | {Γ : Type u_1} → {Λ : Type u_2} → [inst : Inhabited Γ] → Turing.TM0.Cfg Γ Λ → Λ | true |
Lean.Name._impl.casesOn | Init.Prelude | {motive : Lean.Name._impl → Sort u} →
(t : Lean.Name._impl) →
motive Lean.Name.anonymous._impl →
((hash : UInt64) → (pre : Lean.Name) → (str : String) → motive (Lean.Name.str._impl hash pre str)) →
((hash : UInt64) → (pre : Lean.Name) → (i : ℕ) → motive (Lean.Name.num._impl hash pre i)) → motive t | false |
CategoryTheory.Limits.PullbackCone.mk._auto_1 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | Lean.Syntax | false |
Polynomial.resultant_zero_right_deg | Mathlib.RingTheory.Polynomial.Resultant.Basic | ∀ {R : Type u_1} [inst : CommRing R] (f g : Polynomial R) (m : ℕ), f.resultant g m 0 = g.coeff 0 ^ m | true |
SemimoduleCat.MonoidalCategory.leftUnitor_naturality | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommSemiring R] {M N : SemimoduleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp
(SemimoduleCat.MonoidalCategory.tensorHom (CategoryTheory.CategoryStruct.id (SemimoduleCat.of R R)) f)
(SemimoduleCat.MonoidalCategory.leftUnitor N).hom =
CategoryTheory.CategoryStruct.comp (... | true |
AddMonoidHom.exists_mrange_eq_mgraph | Mathlib.Algebra.Group.Graph | ∀ {G : Type u_1} {H : Type u_2} {I : Type u_3} [inst : AddMonoid G] [inst_1 : AddMonoid H] [inst_2 : AddMonoid I]
{f : G →+ H × I},
Function.Surjective (Prod.fst ∘ ⇑f) →
(∀ (g₁ g₂ : G), (f g₁).1 = (f g₂).1 → (f g₁).2 = (f g₂).2) → ∃ f', AddMonoidHom.mrange f = f'.mgraph | true |
_private.Mathlib.SetTheory.ZFC.PSet.0.PSet.Mem.congr_left.match_1_1 | Mathlib.SetTheory.ZFC.PSet | ∀ (x : PSet.{u_1}) (α : Type u_1) (A : α → PSet.{u_1}) (motive : x ∈ PSet.mk α A → Prop) (x_1 : x ∈ PSet.mk α A),
(∀ (a : (PSet.mk α A).Type) (ha : x.Equiv ((PSet.mk α A).Func a)), motive ⋯) → motive x_1 | false |
CategoryTheory.ShortComplex.leftHomologyOpIso | 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] → S.op.leftHomology ≅ Opposite.op S.rightHomology | true |
instIsPartialOrderLe | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : PartialOrder α], IsPartialOrder α fun x1 x2 => x1 ≤ x2 | true |
_private.Lean.Data.Json.Basic.0.Lean.Json.beq'._sparseCasesOn_7 | Lean.Data.Json.Basic | {motive_1 : Lean.Json → Sort u} →
(t : Lean.Json) →
((elems : Array Lean.Json) → motive_1 (Lean.Json.arr elems)) →
(Nat.hasNotBit 16 t.ctorIdx → motive_1 t) → motive_1 t | false |
_private.Mathlib.RingTheory.DiscreteValuationRing.Basic.0.IsDiscreteValuationRing.HasUnitMulPowIrreducibleFactorization.of_ufd_of_unique_irreducible._simp_1_3 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, ((∃ x, p x) → b) = ∀ (x : α), p x → b | false |
CategoryTheory.hasExt_iff_small_ext | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C],
CategoryTheory.HasExt C ↔ ∀ (X Y : C) (n : ℕ), Small.{w', w} (CategoryTheory.Abelian.Ext X Y n) | true |
instIsInertiaFieldOfIsGaloisGroupSubtypeAlgEquivMemSubgroupInertia | Mathlib.NumberTheory.RamificationInertia.HilbertTheory | ∀ (K : Type u_2) (L : Type u_3) {B : Type u_4} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L]
[inst_3 : CommRing B] (P : Ideal B) (E : Type u_6) [inst_4 : Field E] [inst_5 : Algebra E L]
[inst_6 : MulSemiringAction Gal(L/K) B] [h : IsGaloisGroup (↥(Ideal.inertia Gal(L/K) P)) E L], IsInertiaField K L P E | true |
AlgebraicGeometry.Scheme.Hom.normalizationObjIso_hom_val | Mathlib.AlgebraicGeometry.Normalization | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [inst : AlgebraicGeometry.QuasiCompact f]
[inst_1 : AlgebraicGeometry.QuasiSeparated f] {U : Y.Opens} (hU : AlgebraicGeometry.IsAffineOpen U),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.Scheme.Hom.normalizationObjIso f hU).hom
(CommRingCat.ofHom
... | true |
_private.Lean.Environment.0.Lean.Environment.realizeValue.unsafe_15 | Lean.Environment | {α : Type u_1} → [inst : BEq α] → [inst_1 : Hashable α] → Lean.PersistentHashMap α (Task Dynamic) → NonScalar | true |
WithTop.bot_eq_coe._simp_1 | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Bot α] {a : α}, (⊥ = ↑a) = (⊥ = a) | false |
SemicontinuousAt.eq_1 | Mathlib.Topology.Semicontinuity.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] (r : α → β → Prop) (x : α),
SemicontinuousAt r x = ∀ (y : β), r x y → ∀ᶠ (x' : α) in nhds x, r x' y | true |
CategoryTheory.Functor.precomposeWhiskerLeftMapCocone_inv_hom | Mathlib.CategoryTheory.Limits.Cones | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] {C : Type u₃} [inst_1 : CategoryTheory.Category.{v₃, u₃} C]
{D : Type u₄} [inst_2 : CategoryTheory.Category.{v₄, u₄} D] {F : CategoryTheory.Functor J C}
{H H' : CategoryTheory.Functor C D} (α : H ≅ H') (c : CategoryTheory.Limits.Cocone F),
(CategoryTheor... | true |
Localization.mapToFractionRing._proof_1 | Mathlib.RingTheory.Localization.AsSubring | ∀ {A : Type u_3} (K : Type u_1) [inst : CommRing A] (S : Submonoid A) [inst_1 : CommRing K] [inst_2 : Algebra A K]
[inst_3 : IsFractionRing A K] (B : Type u_2) [inst_4 : CommRing B] [inst_5 : Algebra A B]
[inst_6 : IsLocalization S B] (hS : S ≤ nonZeroDivisors A) (a : A),
(↑↑(IsLocalization.lift ⋯)).toFun ((algeb... | false |
NormedField.edist._inherited_default | Mathlib.Analysis.Normed.Field.Basic | {α : Type u_5} →
(dist : α → α → ℝ) →
(∀ (x : α), dist x x = 0) →
(∀ (x y : α), dist x y = dist y x) → (∀ (x y z : α), dist x z ≤ dist x y + dist y z) → α → α → ENNReal | false |
Finset.inter_singleton_of_mem | Mathlib.Data.Finset.Lattice.Lemmas | ∀ {α : Type u_1} [inst : DecidableEq α] {a : α} {s : Finset α}, a ∈ s → s ∩ {a} = {a} | true |
CategoryTheory.Limits.MultispanShape.prod_R | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ (ι : Type w), (CategoryTheory.Limits.MultispanShape.prod ι).R = ι | true |
Northcott.finite_le | Mathlib.NumberTheory.Height.Northcott | ∀ {α : Type u_1} {β : Type u_2} {h : α → β} {inst : LE β} [self : Northcott h] (b : β), {a | h a ≤ b}.Finite | true |
CircularPartialOrder.ctorIdx | Mathlib.Order.Circular | {α : Type u_1} → CircularPartialOrder α → ℕ | false |
Set.mul_iInter₂_subset | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_2} {ι : Sort u_5} {κ : ι → Sort u_6} [inst : Mul α] (s : Set α) (t : (i : ι) → κ i → Set α),
s * ⋂ i, ⋂ j, t i j ⊆ ⋂ i, ⋂ j, s * t i j | true |
Int.getElem?_toList_roc_eq_none_iff._simp_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {m n : ℤ} {i : ℕ}, ((m<...=n).toList[i]? = none) = ((n - m).toNat ≤ i) | false |
_private.Mathlib.Algebra.Polynomial.CoeffList.0.Polynomial.coeffList_eraseLead._proof_1_1 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} [inst : Semiring R] {P : Polynomial R},
¬P.natDegree = 0 →
P.eraseLead.degree.succ = P.eraseLead.natDegree + 1 →
P.eraseLead.natDegree ≤ P.natDegree - 1 →
P.natDegree = P.eraseLead.natDegree + 1 + (P.natDegree - P.eraseLead.natDegree - 1) ∧
P.natDegree - P.eraseLead.natDeg... | false |
Set.preimage_const_mul_Ioo | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : CommGroup α] [inst_1 : PartialOrder α] [IsOrderedMonoid α] (a b c : α),
(fun x => a * x) ⁻¹' Set.Ioo b c = Set.Ioo (b / a) (c / a) | true |
HomologicalComplex.evalCompCoyonedaCorepresentative._proof_1 | Mathlib.Algebra.Homology.Double | ∀ {ι : Type u_1} (c : ComplexShape ι) (j : ι) (hj : ∃ k, c.Rel j k), c.Rel j hj.choose | false |
Quiver.SingleObj.pathToList._sunfold | Mathlib.Combinatorics.Quiver.SingleObj | {α : Type u_1} → {x : Quiver.SingleObj α} → Quiver.Path (Quiver.SingleObj.star α) x → List α | false |
AlgebraicGeometry.Scheme.Opens.mem_basicOpen_toScheme._simp_1 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} {V : (↑U).Opens} {r : ↑((↑U).presheaf.obj (Opposite.op V))} {x : ↥U},
(x ∈ (↑U).basicOpen r) = (↑x ∈ X.basicOpen r) | false |
IsUltrametricDist.algNormOfAlgEquiv_extends | Mathlib.Analysis.Normed.Unbundled.InvariantExtension | ∀ {K : Type u_1} [inst : NormedField K] {L : Type u_2} [inst_1 : Field L] [inst_2 : Algebra K L]
[h_fin : FiniteDimensional K L] [hu : IsUltrametricDist K] (σ : Gal(L/K)) (x : K),
(IsUltrametricDist.algNormOfAlgEquiv σ) ((algebraMap K L) x) = ‖x‖ | true |
ULift.instT5Space | Mathlib.Topology.Separation.Regular | ∀ {X : Type u_1} [inst : TopologicalSpace X] [T5Space X], T5Space (ULift.{u_3, u_1} X) | true |
_private.Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf.0.AlgebraicGeometry.homogeneousLocalizationToStalk_stalkToFiberRingHom._simp_1_1 | Mathlib.AlgebraicGeometry.ProjectiveSpectrum.StructureSheaf | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∀ (x : { a // p a }), q x) = ∀ (a : α) (b : p a), q ⟨a, b⟩ | false |
RelIso.mk.sizeOf_spec | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_5} {β : Type u_6} {r : α → α → Prop} {s : β → β → Prop} [inst : SizeOf α] [inst_1 : SizeOf β]
[inst_2 : (a a_1 : α) → SizeOf (r a a_1)] [inst_3 : (a a_1 : β) → SizeOf (s a a_1)] (toEquiv : α ≃ β)
(map_rel_iff' : ∀ {a b : α}, s (toEquiv a) (toEquiv b) ↔ r a b),
sizeOf { toEquiv := toEquiv, map_rel_if... | true |
OrderedFinpartition.eraseLeft._proof_7 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {n : ℕ} (c : OrderedFinpartition (n + 1)) (i : Fin (c.length - 1)), 0 < c.partSize (Fin.cast ⋯ i.succ) | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.msb_signExtend._proof_1_2 | Init.Data.BitVec.Lemmas | ∀ {w v : ℕ}, ¬w ≥ v → v - w = 0 → False | false |
AddMonoidHom.injective_codRestrict._simp_1 | Mathlib.Algebra.Group.Submonoid.Operations | ∀ {M : Type u_1} {N : Type u_2} [inst : AddZeroClass M] [inst_1 : AddZeroClass N] {S : Type u_5} [inst_2 : SetLike S N]
[inst_3 : AddSubmonoidClass S N] (f : M →+ N) (s : S) (h : ∀ (x : M), f x ∈ s),
Function.Injective ⇑(f.codRestrict s h) = Function.Injective ⇑f | false |
List.any_toArray | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {l : List α}, l.toArray.any p = l.any p | true |
_private.Mathlib.Data.Option.NAry.0.Option.map₂_eq_some_iff._proof_1_1 | Mathlib.Data.Option.NAry | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_1} {f : α → β → γ} {a : Option α} {b : Option β} {c : γ},
Option.map₂ f a b = some c ↔ ∃ a' b', a' ∈ a ∧ b' ∈ b ∧ f a' b' = c | false |
Lean.Compiler.LCNF.ToMonoM.State.noConfusionType | Lean.Compiler.LCNF.ToMono | Sort u → Lean.Compiler.LCNF.ToMonoM.State → Lean.Compiler.LCNF.ToMonoM.State → Sort u | false |
_private.Mathlib.Logic.IsEmpty.Basic.0.leftTotal_iff_isEmpty_left._simp_1_2 | Mathlib.Logic.IsEmpty.Basic | ∀ {α : Sort u} [IsEmpty α] {p : α → Prop}, (∃ a, p a) = False | false |
CategoryTheory.NatTrans.ext | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {D : Type u₂} {inst_1 : CategoryTheory.Category.{v₂, u₂} D}
{F G : CategoryTheory.Functor C D} {x y : CategoryTheory.NatTrans F G}, x.app = y.app → x = y | true |
Ordnode.Bounded.mem_lt | Mathlib.Data.Ordmap.Invariants | ∀ {α : Type u_1} [inst : Preorder α] {t : Ordnode α} {o : WithBot α} {x : α},
t.Bounded o ↑x → Ordnode.All (fun x_1 => x_1 < x) t | true |
TopologicalGroup.IsSES.pushforward._proof_7 | Mathlib.MeasureTheory.Measure.Haar.Extension | ∀ {A : Type u_3} {B : Type u_4} {C : Type u_1} {E : Type u_2} [inst : Group A] [inst_1 : Group B] [inst_2 : Group C]
[inst_3 : TopologicalSpace A] [inst_4 : TopologicalSpace B] [inst_5 : TopologicalSpace C] {φ : A →* B} {ψ : B →* C}
(H : TopologicalGroup.IsSES φ ψ) [inst_6 : IsTopologicalGroup A] [inst_7 : IsTopolo... | false |
Lean.Meta.MatcherApp.mk._flat_ctor | Lean.Meta.Match.MatcherApp.Basic | ℕ →
ℕ →
Array Lean.Meta.Match.AltParamInfo →
Option ℕ →
Array Lean.Meta.Match.DiscrInfo →
Lean.Meta.Match.Overlaps →
Lean.Name →
Array Lean.Level →
Array Lean.Expr → Lean.Expr → Array Lean.Expr → Array Lean.Expr → Array Lean.Expr → Lean.Meta.Matche... | false |
Real.normedField._proof_1 | Mathlib.Analysis.Normed.Field.Basic | ∀ (a b : ℝ), a + b = b + a | false |
Units.liftRight._proof_1 | Mathlib.Algebra.Group.Units.Hom | ∀ {M : Type u_2} {N : Type u_1} [inst : Monoid M] [inst_1 : Monoid N] (f : M →* N) (g : M → Nˣ),
(∀ (x : M), ↑(g x) = f x) → g 1 = 1 | false |
SSet.RelativeMorphism.Homotopy.h₀._autoParam | Mathlib.AlgebraicTopology.SimplicialSet.RelativeMorphism | Lean.Syntax | false |
List.ranges._sunfold | Mathlib.Data.List.Range | List ℕ → List (List ℕ) | false |
Turing.PartrecToTM2.contSupp.eq_3 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (f : Turing.ToPartrec.Code) (k : Turing.PartrecToTM2.Cont'),
Turing.PartrecToTM2.contSupp (Turing.PartrecToTM2.Cont'.comp f k) =
Turing.PartrecToTM2.codeSupp' f k ∪ Turing.PartrecToTM2.contSupp k | true |
_private.Lean.Elab.Extra.0.Lean.Elab.Term.Op.Tree.unop.inj | Lean.Elab.Extra | ∀ {ref : Lean.Syntax} {f : Lean.Expr} {arg : Lean.Elab.Term.Op.Tree✝} {ref_1 : Lean.Syntax} {f_1 : Lean.Expr}
{arg_1 : Lean.Elab.Term.Op.Tree✝¹},
Lean.Elab.Term.Op.Tree.unop✝ ref f arg = Lean.Elab.Term.Op.Tree.unop✝¹ ref_1 f_1 arg_1 →
ref = ref_1 ∧ f = f_1 ∧ arg = arg_1 | true |
Stream'.WSeq.productive_tail | Mathlib.Data.WSeq.Productive | ∀ {α : Type u} (s : Stream'.WSeq α) [s.Productive], s.tail.Productive | true |
PiLp.norm_single | Mathlib.Analysis.Normed.Lp.PiLp | ∀ (p : ENNReal) {ι : Type u_2} (β : ι → Type u_4) [hp : Fact (1 ≤ p)] [inst : Fintype ι]
[inst_1 : (i : ι) → SeminormedAddCommGroup (β i)] [inst_2 : DecidableEq ι] (i : ι) (b : β i),
‖PiLp.single p i b‖ = ‖b‖ | true |
Matrix.conjTranspose_list_sum | Mathlib.LinearAlgebra.Matrix.ConjTranspose | ∀ {m : Type u_2} {n : Type u_3} {α : Type v} [inst : AddMonoid α] [inst_1 : StarAddMonoid α] (l : List (Matrix m n α)),
l.sum.conjTranspose = (List.map Matrix.conjTranspose l).sum | true |
SimpleGraph.ConnectedComponent.connected_toSubgraph | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u} {G : SimpleGraph V} (C : G.ConnectedComponent), C.toSubgraph.Connected | true |
WeierstrassCurve.Jacobian.Point.instAddCommGroup._proof_8 | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u_1} [inst : Field F] {W : WeierstrassCurve.Jacobian F} (n : ℕ) (a : W.Point),
zsmulRec nsmulRec (↑n.succ) a = zsmulRec nsmulRec (↑n) a + a | false |
Fin.succ_lt_succ_iff._simp_1 | Init.Data.Fin.Lemmas | ∀ {n : ℕ} {a b : Fin n}, (a.succ < b.succ) = (a < b) | false |
Std.TreeMap.Raw.contains_ofList | Std.Data.TreeMap.Raw.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [Std.TransCmp cmp] [inst : BEq α] [Std.LawfulBEqCmp cmp]
{l : List (α × β)} {k : α}, (Std.TreeMap.Raw.ofList l cmp).contains k = (List.map Prod.fst l).contains k | true |
CategoryTheory.CartesianClosed.curry_id_eq_coev | Mathlib.CategoryTheory.Monoidal.Closed.Cartesian | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A X : C)
[inst_2 : CategoryTheory.Closed A],
CategoryTheory.MonoidalClosed.curry
(CategoryTheory.CategoryStruct.id
(CategoryTheory.MonoidalCategoryStruct.tensorObj A ((CategoryTheory.Functor.id C).ob... | true |
FirstOrder.Language.ElementaryEmbedding.noConfusion | Mathlib.ModelTheory.ElementaryMaps | {P : Sort u} →
{L : FirstOrder.Language} →
{M : Type u_1} →
{N : Type u_2} →
{inst : L.Structure M} →
{inst_1 : L.Structure N} →
{t : L.ElementaryEmbedding M N} →
{L' : FirstOrder.Language} →
{M' : Type u_1} →
{N' : Type u_2} →
... | false |
antivaryOn_neg | Mathlib.Algebra.Order.Monovary | ∀ {ι : Type u_1} {α : Type u_2} {β : Type u_3} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α]
[inst_3 : AddCommGroup β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] {s : Set ι} {f : ι → α} {g : ι → β},
AntivaryOn (-f) (-g) s ↔ AntivaryOn f g s | true |
Ordnode.splitMax | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → Ordnode α → Option (Ordnode α × α) | true |
CategoryTheory.Comma.leftIso | Mathlib.CategoryTheory.Comma.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{T : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} T] →
{L₁ : CategoryTheory.Functor A T} →
{R₁ : CategoryTheory.Functor B T} → {X... | true |
Matroid.ext_spanning | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M M' : Matroid α}, M.E = M'.E → (∀ S ⊆ M.E, M.Spanning S ↔ M'.Spanning S) → M = M' | true |
Nat.Linear.PolyCnstr.mk | Init.Data.Nat.Linear | Bool → Nat.Linear.Poly → Nat.Linear.Poly → Nat.Linear.PolyCnstr | true |
_private.Std.Time.Format.Basic.0.Std.Time.instReprFormatPart.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.FormatPart → Sort u_1) →
(x : Std.Time.FormatPart) →
((a : String) → motive (Std.Time.FormatPart.string a)) →
((a : Std.Time.Modifier) → motive (Std.Time.FormatPart.modifier a)) → motive x | false |
Function.locallyFinsuppWithin.instMaxOfSemilatticeSup | Mathlib.Topology.LocallyFinsupp | {X : Type u_1} →
[inst : TopologicalSpace X] →
{U : Set X} → {Y : Type u_2} → [SemilatticeSup Y] → [inst_2 : Zero Y] → Max (Function.locallyFinsuppWithin U Y) | true |
WithCStarModule.inner_single_right | Mathlib.Analysis.CStarAlgebra.Module.Constructions | ∀ {A : Type u_1} [inst : NonUnitalCStarAlgebra A] [inst_1 : PartialOrder A] {ι : Type u_2} {E : ι → Type u_3}
[inst_2 : Fintype ι] [inst_3 : (i : ι) → NormedAddCommGroup (E i)] [inst_4 : (i : ι) → Module ℂ (E i)]
[inst_5 : (i : ι) → SMul A (E i)] [inst_6 : (i : ι) → CStarModule A (E i)] [inst_7 : StarOrderedRing A]... | true |
Aesop.MVarClusterData.goals | Aesop.Tree.Data | {Goal Rapp : Type} → Aesop.MVarClusterData Goal Rapp → Array (IO.Ref Goal) | true |
ProofWidgets.CheckRequestResponse.noConfusion | ProofWidgets.Cancellable | {P : Sort u} →
{t t' : ProofWidgets.CheckRequestResponse} → t = t' → ProofWidgets.CheckRequestResponse.noConfusionType P t t' | false |
_private.Init.Data.Vector.Basic.0.Vector.mapM.go._unary._proof_4 | Init.Data.Vector.Basic | ∀ {n : ℕ}, ∀ k < n, k + 1 ≤ n | false |
_private.Lean.Server.Completion.CompletionItemCompression.0.Lean.Lsp.ResolvableCompletionList.compressEditFast | Lean.Server.Completion.CompletionItemCompression | String → Lean.Lsp.InsertReplaceEdit → String | true |
_private.Mathlib.Combinatorics.Matroid.Circuit.0.Matroid.fundCircuit_eq_sInter._simp_1_2 | Mathlib.Combinatorics.Matroid.Circuit | ∀ {α : Type u_1} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) | false |
ULift.mul | Mathlib.Algebra.Group.ULift | {α : Type u} → [Mul α] → Mul (ULift.{u_1, u} α) | true |
LowerSemicontinuousWithinAt.le_liminf | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {x : α} {γ : Type u_4} [inst_1 : CompleteLinearOrder γ]
{f : α → γ}, LowerSemicontinuousWithinAt f s x → f x ≤ Filter.liminf f (nhdsWithin x s) | true |
Int.Nonneg.mul | Init.Data.Int.OfNat | ∀ (a b : ℤ), a ≥ 0 → b ≥ 0 → a * b ≥ 0 | true |
Finset.Ico_subset_Iio_self | Mathlib.Order.Interval.Finset.Basic | ∀ {α : Type u_2} {a b : α} [inst : Preorder α] [inst_1 : LocallyFiniteOrderBot α] [inst_2 : LocallyFiniteOrder α],
Finset.Ico a b ⊆ Finset.Iio b | true |
measurable_to_countable' | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [Countable α] [inst_2 : MeasurableSpace β] {f : β → α},
(∀ (x : α), MeasurableSet (f ⁻¹' {x})) → Measurable f | true |
«_aux_Mathlib_NumberTheory_Padics_Complex___macroRules_term𝓞_ℂ_[_]_1» | Mathlib.NumberTheory.Padics.Complex | Lean.Macro | false |
CategoryTheory.MonoidalCategory.selfLeftAction._proof_13 | Mathlib.CategoryTheory.Monoidal.Action.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] (c : C)
{c' c'' : C} (f : c' ⟶ c'') (d : C),
CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheory.MonoidalCategoryStruct.whiskerLeft c f) d =
CategoryTheory.CategoryStruct.comp (CategoryTheo... | false |
CancelCommMonoidWithZero.mk.sizeOf_spec | Mathlib.Algebra.GroupWithZero.Defs | ∀ {M₀ : Type u_2} [inst : SizeOf M₀] (toCommMonoidWithZero : CommMonoidWithZero M₀)
(toIsLeftCancelMulZero : IsLeftCancelMulZero M₀),
sizeOf { toCommMonoidWithZero := toCommMonoidWithZero, toIsLeftCancelMulZero := toIsLeftCancelMulZero } =
1 + sizeOf toCommMonoidWithZero + sizeOf toIsLeftCancelMulZero | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.