name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Limits.Trident.IsLimit.homIso._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type u_3} {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} {f : J → (X ⟶ Y)}
[inst_1 : Nonempty J] {t : CategoryTheory.Limits.Trident f} (ht : CategoryTheory.Limits.IsLimit t) (Z : C)
(x : Z ⟶ t.pt), ↑(CategoryTheory.Limits.Trident.IsLimit.lift' ht ↑⟨CategoryTheory.CategoryStruct.comp x... | false |
Nat.pow_lt_ascFactorial | Mathlib.Data.Nat.Factorial.Basic | ∀ (n : ℕ) {k : ℕ}, 2 ≤ k → (n + 1) ^ k < (n + 1).ascFactorial k | true |
WeierstrassCurve.Jacobian.isUnit_Y_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Basic | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F},
W.Nonsingular P → P 2 = 0 → IsUnit (P 1) | true |
Mathlib.Tactic.Order.Graph.findSCCsImp | Mathlib.Tactic.Order.Graph.Tarjan | Mathlib.Tactic.Order.Graph → StateM Mathlib.Tactic.Order.Graph.TarjanState Unit | true |
Std.DHashMap.Raw.Const.get?_congr | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} {m : Std.DHashMap.Raw α fun x => β} [EquivBEq α]
[LawfulHashable α],
m.WF → ∀ {a b : α}, (a == b) = true → Std.DHashMap.Raw.Const.get? m a = Std.DHashMap.Raw.Const.get? m b | true |
CategoryTheory.Limits.Sigma.map_comp_map | Mathlib.CategoryTheory.Limits.Shapes.Products | ∀ {α : Type w₂} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {f g h : α → C}
[inst_1 : CategoryTheory.Limits.HasCoproduct f] [inst_2 : CategoryTheory.Limits.HasCoproduct g]
[inst_3 : CategoryTheory.Limits.HasCoproduct h] (q : (a : α) → f a ⟶ g a) (q' : (a : α) → g a ⟶ h a),
CategoryTheory.CategoryStruct... | true |
Set.fintypeLENat._simp_1 | Mathlib.Data.Set.Finite.Basic | ∀ {m n : ℕ}, (m < n.succ) = (m ≤ n) | false |
Lean.Parser.Term.letrec._regBuiltin.Lean.Parser.Term.letrec.parenthesizer_123 | Lean.Parser.Term | IO Unit | false |
TopCat.«term∂𝔻_» | Mathlib.Topology.Category.TopCat.Sphere | Lean.ParserDescr | true |
_private.Mathlib.Analysis.MellinInversion.0.mellin_eq_fourier._simp_1_1 | Mathlib.Analysis.MellinInversion | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 2] [NeZero 2], (2 = 0) = False | false |
CategoryTheory.Limits.WidePullbackShape.struct._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type u_1}, none = none | false |
BiheytingHomClass.map_sdiff | Mathlib.Order.Heyting.Hom | ∀ {F : Type u_6} {α : Type u_7} {β : Type u_8} {inst : BiheytingAlgebra α} {inst_1 : BiheytingAlgebra β}
{inst_2 : FunLike F α β} [self : BiheytingHomClass F α β] (f : F) (a b : α), f (a \ b) = f a \ f b | true |
Subtype.map_eq | Mathlib.Data.Subtype | ∀ {α : Sort u_1} {β : Sort u_2} {p : α → Prop} {q : β → Prop} {f g : α → β} (h₁ : ∀ (a : α), p a → q (f a))
(h₂ : ∀ (a : α), p a → q (g a)) {x y : Subtype p}, Subtype.map f h₁ x = Subtype.map g h₂ y ↔ f ↑x = g ↑y | true |
measurableSMul₂_of_add | Mathlib.MeasureTheory.Group.Arithmetic | ∀ (M : Type u_2) [inst : Add M] [inst_1 : MeasurableSpace M] [MeasurableAdd₂ M], MeasurableVAdd₂ M M | true |
Vector.forall_getElem | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {p : α → Prop}, (∀ (i : ℕ) (h : i < n), p xs[i]) ↔ ∀ a ∈ xs, p a | true |
FractionalIdeal.isPrincipal_of_isPrincipal_num | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] [IsDomain R] (I : FractionalIdeal (nonZeroDivisors R) (FractionRing R)),
Submodule.IsPrincipal I.num → (↑I).IsPrincipal | true |
CategoryTheory.StructuredArrow.commaMapEquivalenceInverse_obj | Mathlib.CategoryTheory.Comma.StructuredArrow.CommaMap | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L : CategoryTheory.Functor C T}
{R : CategoryTheory.Functor D T} {C' : Type u₄} [inst_3 : CategoryTheory.Category.{v₄, u₄} C'] {D' : Ty... | true |
CategoryTheory.Limits.PullbackCone.flipIsLimit._proof_2 | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackCone | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y Z : C} {f : X ⟶ Z} {g : Y ⟶ Z}
{t : CategoryTheory.Limits.PullbackCone f g} (ht : CategoryTheory.Limits.IsLimit t)
(s : CategoryTheory.Limits.PullbackCone g f),
CategoryTheory.CategoryStruct.comp ((fun s => ht.lift s.flip) s) t.fst = s.snd | false |
_private.Lean.Elab.Do.Basic.0.Lean.Elab.Do.elabDoElemFns.match_1 | Lean.Elab.Do.Basic | (motive : Lean.Exception → Sort u_1) →
(ex : Lean.Exception) →
((id : Lean.InternalExceptionId) → (extra : Lean.KVMap) → motive (Lean.Exception.internal id extra)) →
((x : Lean.Exception) → motive x) → motive ex | false |
CategoryTheory.Bicategory.iterated_mateEquiv_conjugateEquiv_symm | Mathlib.CategoryTheory.Bicategory.Adjunction.Mate | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c d : B} {f₁ : a ⟶ c} {u₁ : c ⟶ a} {f₂ : b ⟶ d} {u₂ : d ⟶ b}
{l₁ : a ⟶ b} {r₁ : b ⟶ a} {l₂ : c ⟶ d} {r₂ : d ⟶ c} (adj₁ : CategoryTheory.Bicategory.Adjunction l₁ r₁)
(adj₂ : CategoryTheory.Bicategory.Adjunction l₂ r₂) (adj₃ : CategoryTheory.Bicategory.Adjuncti... | true |
CategoryTheory.TwistShiftData.z_zero_left | Mathlib.CategoryTheory.Shift.Twist | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : Type w} [inst_1 : AddMonoid A]
[inst_2 : CategoryTheory.HasShift C A] (t : CategoryTheory.TwistShiftData C A) (b : A), t.z 0 b = 1 | true |
LinearOrderedCommGroupWithZero.discrete_iff_not_denselyOrdered | Mathlib.GroupTheory.ArchimedeanDensely | ∀ (G : Type u_2) [inst : LinearOrderedCommGroupWithZero G] [Nontrivial Gˣ] [MulArchimedean G],
Nonempty (G ≃*o WithZero (Multiplicative ℤ)) ↔ ¬DenselyOrdered G | true |
Real.exp_approx_end' | Mathlib.Analysis.Complex.Exponential | ∀ {n : ℕ} {x a b : ℝ} (m : ℕ),
n + 1 = m →
∀ (rm : ℝ),
↑m = rm →
|x| ≤ 1 →
|1 - a| ≤ b - |x| / rm * ((rm + 1) / rm) → |Real.exp x - Real.expNear n x a| ≤ |x| ^ n / ↑n.factorial * b | true |
ite_nonpos | Mathlib.Algebra.Notation.Lemmas | ∀ {α : Type u_1} [inst : Zero α] {p : Prop} [inst_1 : Decidable p] {a b : α} [inst_2 : LE α],
a ≤ 0 → b ≤ 0 → (if p then a else b) ≤ 0 | true |
Part.get_eq_of_mem | Mathlib.Data.Part | ∀ {α : Type u_1} {o : Part α} {a : α}, a ∈ o → ∀ (h' : o.Dom), o.get h' = a | true |
DirectLimit.lift_injective | Mathlib.Order.DirectedInverseSystem | ∀ {ι : Type u_1} [inst : Preorder ι] {F : ι → Type u_4} {T : ⦃i j : ι⦄ → i ≤ j → Sort u_8}
(f : (i j : ι) → (h : i ≤ j) → T h) [inst_1 : ⦃i j : ι⦄ → (h : i ≤ j) → FunLike (T h) (F i) (F j)]
[inst_2 : DirectedSystem F fun x1 x2 x3 => ⇑(f x1 x2 x3)] [inst_3 : IsDirectedOrder ι] {C : Sort u_9}
(ih : (i : ι) → F i → ... | true |
Std.Sat.AIG.relabel.eq_1 | Std.Sat.AIG.Relabel | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {β : Type} [inst_2 : Hashable β] [inst_3 : DecidableEq β]
(r : α → β) (aig : Std.Sat.AIG α),
Std.Sat.AIG.relabel r aig =
{ decls := Array.map (Std.Sat.AIG.Decl.relabel r) aig.decls, cache := Std.Sat.AIG.Cache.empty, hdag := ⋯,
hzero := ⋯, hconst :=... | true |
_private.Lean.Meta.Tactic.Simp.Main.0.Lean.Meta.Simp.unfold?.unfoldDeclToUnfold?.match_1 | Lean.Meta.Tactic.Simp.Main | (motive : Option Lean.ConstantInfo → Sort u_1) →
(x : Option Lean.ConstantInfo) →
((cinfo : Lean.ConstantInfo) → motive (some cinfo)) → ((x : Option Lean.ConstantInfo) → motive x) → motive x | false |
CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono | Mathlib.CategoryTheory.Abelian.DiagramLemmas.Four | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{R₁ R₂ : CategoryTheory.ComposableArrows C 3} (φ : R₁ ⟶ R₂),
R₁.Exact →
R₂.Exact →
CategoryTheory.Epi
(CategoryTheory.ComposableArrows.app' φ 0 CategoryTheory.Abelian.mono_of_epi_of_mono_of_mono'._... | true |
UInt16.ne_not_self | Init.Data.UInt.Bitwise | ∀ {a : UInt16}, a ≠ ~~~a | true |
_private.Lean.Compiler.IR.EmitC.0.Lean.IR.EmitC.isIf._proof_5 | Lean.Compiler.IR.EmitC | ∀ (alts : Array Lean.IR.Alt), ¬alts.size ≠ 2 → ¬1 < alts.size → False | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord.0.NumberField.mixedEmbedding.volume_eq_two_pi_pow_mul_integral._simp_1_3 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.PolarCoord | ∀ {α : Type u} [inst : NonAssocSemiring α] (n : α), n + n = 2 * n | false |
Module.AEval.restrict_equiv_mapSubmodule._proof_2 | Mathlib.Algebra.Polynomial.Module.AEval | ∀ {R : Type u_2} {A : Type u_3} {M : Type u_1} [inst : CommSemiring R] [inst_1 : Semiring A] (a : A)
[inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module A M] [inst_5 : Module R M]
[inst_6 : IsScalarTower R A M] (p : Submodule R M) (hp : p ∈ ((Algebra.lsmul R R M) a).invtSubmodule) (x : ↥p),
(Module... | false |
HomotopicalAlgebra.RightHomotopyClass.precomp_bijective_of_weakEquivalence | Mathlib.AlgebraicTopology.ModelCategory.Homotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.ModelCategory C] {X Y : C} (Z : C)
[HomotopicalAlgebra.IsFibrant Z] (f : X ⟶ Y) [HomotopicalAlgebra.IsCofibrant X] [HomotopicalAlgebra.IsCofibrant Y]
[HomotopicalAlgebra.WeakEquivalence f], Function.Bijective fun g => g.precomp f | true |
SetRel.isCover_univ._simp_1 | Mathlib.Data.Rel.Cover | ∀ {X : Type u_1} {s N : Set X}, SetRel.IsCover Set.univ s N = (s.Nonempty → N.Nonempty) | false |
UInt64.toFin_not | Init.Data.UInt.Bitwise | ∀ (a : UInt64), (~~~a).toFin = a.toFin.rev | true |
LocallyFiniteSupport.locallyFinite_support | Mathlib.Topology.LocallyFinsupp | ∀ {X : Type u_1} [inst : TopologicalSpace X] {Y : Type u_2} [inst_1 : Zero Y] (f : X → Y),
LocallyFiniteSupport f → LocallyFinite fun s => {↑s} | true |
wrapped._@.Mathlib.Analysis.Calculus.FDeriv.Defs.639413672._hygCtx._hyg.8 | Mathlib.Analysis.Calculus.FDeriv.Defs | Subtype (Eq definition✝) | false |
UniformOnFun.hasBasis_nhds_zero_of_basis | Mathlib.Topology.Algebra.UniformConvergence | ∀ {α : Type u_1} {G : Type u_2} {ι : Type u_3} [inst : AddGroup G] [inst_1 : UniformSpace G] [IsUniformAddGroup G]
(𝔖 : Set (Set α)),
𝔖.Nonempty →
DirectedOn (fun x1 x2 => x1 ⊆ x2) 𝔖 →
∀ {p : ι → Prop} {b : ι → Set G},
(nhds 0).HasBasis p b →
(nhds 0).HasBasis (fun Si => Si.1 ∈ 𝔖 ∧ p... | true |
USize.toNat.eq_1 | Init.Data.UInt.Lemmas | ∀ (n : USize), n.toNat = n.toBitVec.toNat | true |
Nat.cast_list_sum | Mathlib.Algebra.BigOperators.Ring.Finset | ∀ {R : Type u_4} [inst : AddMonoidWithOne R] (s : List ℕ), ↑s.sum = (List.map Nat.cast s).sum | true |
MonoidHom.instCommMonoid._proof_6 | Mathlib.Algebra.Group.Hom.Instances | ∀ {M : Type u_1} {N : Type u_2} [inst : MulOneClass M] [inst_1 : CommMonoid N] (a b : M →* N), a * b = b * a | false |
Std.TreeSet.Raw.getD_ofList_of_mem | Std.Data.TreeSet.Raw.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} [Std.TransCmp cmp] {l : List α} {k k' fallback : α},
cmp k k' = Ordering.eq →
List.Pairwise (fun a b => ¬cmp a b = Ordering.eq) l → k ∈ l → (Std.TreeSet.Raw.ofList l cmp).getD k' fallback = k | true |
AlgebraicGeometry.IsNoetherian.mk | Mathlib.AlgebraicGeometry.Noetherian | ∀ {X : AlgebraicGeometry.Scheme} [toIsLocallyNoetherian : AlgebraicGeometry.IsLocallyNoetherian X]
[toCompactSpace : CompactSpace ↥X], AlgebraicGeometry.IsNoetherian X | true |
FirstOrder.Field.FieldAxiom.existsPairNE.sizeOf_spec | Mathlib.ModelTheory.Algebra.Field.Basic | sizeOf FirstOrder.Field.FieldAxiom.existsPairNE = 1 | true |
CategoryTheory.Limits.PreservesPullback.iso.eq_1 | Mathlib.CategoryTheory.Limits.Preserves.Shapes.Pullbacks | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(G : CategoryTheory.Functor C D) {X Y Z : C} (f : X ⟶ Z) (g : Y ⟶ Z)
[inst_2 : CategoryTheory.Limits.PreservesLimit (CategoryTheory.Limits.cospan f g) G]
[inst_3 : CategoryTheory.Limits.HasPullb... | true |
Lean.Meta.LazyDiscrTree.patternPath | Lean.Meta.LazyDiscrTree | Lean.Expr → Lean.MetaM (Array Lean.Meta.LazyDiscrTree.Key) | true |
CategoryTheory.MonoidalLinear.casesOn | Mathlib.CategoryTheory.Monoidal.Linear | {R : Type u_1} →
[inst : Semiring R] →
{C : Type u_2} →
[inst_1 : CategoryTheory.Category.{v_1, u_2} C] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Linear R C] →
[inst_4 : CategoryTheory.MonoidalCategory C] →
[inst_5 : CategoryTheory.Monoi... | false |
MeasureTheory.OuterMeasure.isCaratheodory_disjointed | Mathlib.MeasureTheory.OuterMeasure.Caratheodory | ∀ {α : Type u} (m : MeasureTheory.OuterMeasure α) {ι : Type u_1} [inst : Preorder ι] [inst_1 : LocallyFiniteOrderBot ι]
{s : ι → Set α}, (∀ (i : ι), m.IsCaratheodory (s i)) → ∀ (i : ι), m.IsCaratheodory (disjointed s i) | true |
Std.ExtDTreeMap.Const.size_alter_eq_add_one | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t : Std.ExtDTreeMap α (fun x => β) cmp} [inst : Std.TransCmp cmp]
{k : α} {f : Option β → Option β},
k ∉ t → (f (Std.ExtDTreeMap.Const.get? t k)).isSome = true → (Std.ExtDTreeMap.Const.alter t k f).size = t.size + 1 | true |
inseparable_iff_forall_isOpen | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X] {x y : X}, Inseparable x y ↔ ∀ (s : Set X), IsOpen s → (x ∈ s ↔ y ∈ s) | true |
PowerSeries.invUnitsSub_mul_X | Mathlib.RingTheory.PowerSeries.WellKnown | ∀ {R : Type u_1} [inst : Ring R] (u : Rˣ),
PowerSeries.invUnitsSub u * PowerSeries.X = PowerSeries.invUnitsSub u * PowerSeries.C ↑u - 1 | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.instBEqKey.beq._sparseCasesOn_2 | Lean.Compiler.LCNF.InferBorrow | {motive : Lean.Compiler.LCNF.ParamMap.Key✝ → Sort u} →
(t : Lean.Compiler.LCNF.ParamMap.Key✝¹) →
((name : Lean.Name) → (jpId : Lean.FVarId) → motive (Lean.Compiler.LCNF.ParamMap.Key.jp✝ name jpId)) →
(Nat.hasNotBit 2 (Lean.Compiler.LCNF.ParamMap.Key.ctorIdx✝ t) → motive t) → motive t | false |
Polynomial.X_pow_sub_one_splits | Mathlib.RingTheory.Polynomial.Cyclotomic.Basic | ∀ {K : Type u_1} [inst : Field K] {ζ : K} {n : ℕ}, IsPrimitiveRoot ζ n → (Polynomial.X ^ n - Polynomial.C 1).Splits | true |
derivWithin_const | Mathlib.Analysis.Calculus.Deriv.Basic | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] (s : Set 𝕜) (c : F), derivWithin (Function.const 𝕜 c) s = 0 | true |
CochainComplex.mappingCone.inr_fst_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
{d e f : ℤ} (γ : CochainComplex.HomComplex.Cochain F K d) (he : 1 + d = e) (hf : 0 + e = f),
(Coch... | true |
finsum_mem_def | Mathlib.Algebra.BigOperators.Finprod | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] (s : Set α) (f : α → M),
∑ᶠ (a : α) (_ : a ∈ s), f a = ∑ᶠ (a : α), s.indicator f a | true |
Finset.prod_mulIndicator_eq_prod_inter | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {β : Type u_4} [inst : CommMonoid β] [inst_1 : DecidableEq ι] (s t : Finset ι) (f : ι → β),
∏ i ∈ s, (↑t).mulIndicator f i = ∏ i ∈ s ∩ t, f i | true |
TensorPower.toTensorAlgebra | Mathlib.LinearAlgebra.TensorAlgebra.ToTensorPower | {R : Type u_1} →
{M : Type u_2} →
[inst : CommSemiring R] →
[inst_1 : AddCommMonoid M] → [inst_2 : Module R M] → {n : ℕ} → TensorPower R n M →ₗ[R] TensorAlgebra R M | true |
instOrOpInt64 | Init.Data.SInt.Basic | OrOp Int64 | true |
CategoryTheory.IsFiltered.of_right_adjoint | Mathlib.CategoryTheory.Filtered.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [CategoryTheory.IsFiltered C] {D : Type u₁}
[inst_2 : CategoryTheory.Category.{v₁, u₁} D] {L : CategoryTheory.Functor D C} {R : CategoryTheory.Functor C D}
(h : L ⊣ R), CategoryTheory.IsFiltered D | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_45 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (head : α) (tail : List α) (i : ℕ),
tail.length + 1 ≤ i →
i + 1 ≤ (head :: tail).length → (head :: tail).length + 1 ≤ tail.length → tail.length < tail.length | false |
VectorBundle.continuousLinearEquivAt | Mathlib.Topology.VectorBundle.Basic | (R : Type u_1) →
{B : Type u_2} →
(F : Type u_3) →
(E : B → Type u_4) →
[inst : NontriviallyNormedField R] →
[inst_1 : (x : B) → AddCommMonoid (E x)] →
[inst_2 : (x : B) → Module R (E x)] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace R ... | true |
_private.Mathlib.Data.Finset.Powerset.0.Finset.pairwiseDisjoint_pair_insert._simp_1_3 | Mathlib.Data.Finset.Powerset | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastExtract._proof_8 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Extract | ∀ {newWidth : ℕ}, 0 ≤ newWidth | false |
ContDiffWithinAt.ccosh | Mathlib.Analysis.SpecialFunctions.Trigonometric.DerivHyp | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℂ E] {f : E → ℂ} {x : E} {s : Set E}
{n : WithTop ℕ∞}, ContDiffWithinAt ℂ n f s x → ContDiffWithinAt ℂ n (fun x => Complex.cosh (f x)) s x | true |
MultilinearMap.uncurry_curryLeft | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryLeft.uncurryLeft = f | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.0._regBuiltin.Nat.reduceMod.declare_46._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat.3686920086._hygCtx._hyg.19 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Nat | IO Unit | false |
Std.TreeSet.minD_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k fallback : α},
(t.insert k).minD fallback = t.min?.elim k fun k' => if cmp k k' = Ordering.lt then k else k' | true |
Std.Format.FlattenBehavior.fill.sizeOf_spec | Init.Data.Format.Basic | sizeOf Std.Format.FlattenBehavior.fill = 1 | true |
Polynomial.eval_sumIDeriv_of_pos | Mathlib.Algebra.Polynomial.SumIteratedDerivative | ∀ {R : Type u_1} [inst : CommRing R] [Nontrivial R] [NoZeroDivisors R] (p : Polynomial R) {q : ℕ},
0 < q →
∃ gp,
gp.natDegree ≤ p.natDegree - q ∧
∀ (r : R) {p' : Polynomial R},
p = (Polynomial.X - Polynomial.C r) ^ (q - 1) * p' →
Polynomial.eval r (Polynomial.sumIDeriv p) =
... | true |
List.isChain_range | Mathlib.Data.List.Range | ∀ (r : ℕ → ℕ → Prop) (n : ℕ), List.IsChain r (List.range n) ↔ ∀ m < n - 1, r m m.succ | true |
isScalarTower_closedBall_closedBall_closedBall | Mathlib.Analysis.Normed.Module.Ball.Action | ∀ {𝕜 : Type u_1} {𝕜' : Type u_2} {E : Type u_3} [inst : NormedField 𝕜] [inst_1 : NormedField 𝕜']
[inst_2 : SeminormedAddCommGroup E] [inst_3 : NormedSpace 𝕜 E] [inst_4 : NormedSpace 𝕜' E] {r : ℝ}
[inst_5 : NormedAlgebra 𝕜 𝕜'] [IsScalarTower 𝕜 𝕜' E],
IsScalarTower ↑(Metric.closedBall 0 1) ↑(Metric.closed... | true |
HasFibers.inducedMap_comp_assoc | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
{p : CategoryTheory.Functor 𝒳 𝒮} [inst_2 : HasFibers p] {R S : 𝒮} {a : 𝒳} {b b' : HasFibers.Fib p R} (f : R ⟶ S)
(ψ : (HasFibers.ι R).obj b' ⟶ a) [inst_3 : p.IsCartesian f ψ] (φ : (HasFibe... | true |
CategoryTheory.CommGrp.instCategory._proof_9 | Mathlib.CategoryTheory.Monoidal.CommGrp_ | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C],
autoParam
(∀ {W X Y Z : CategoryTheory.CommGrp C} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.Catego... | false |
Unitization.instRing._proof_7 | Mathlib.Algebra.Algebra.Unitization | ∀ {R : Type u_1} {A : Type u_2} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : Unitization R A), -a + a = 0 | false |
AddUnits.neg_nsmul_eq_nsmul_neg | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : AddMonoid α] (a : AddUnits α) (n : ℕ), ↑(-(n • a)) = n • ↑(-a) | true |
OreLocalization.oreDivSMulChar'.eq_1 | Mathlib.GroupTheory.OreLocalization.Basic | ∀ {R : Type u_1} [inst : Monoid R] {S : Submonoid R} [inst_1 : OreLocalization.OreSet S] {X : Type u_2}
[inst_2 : MulAction R X] (r₁ : R) (r₂ : X) (s₁ s₂ : ↥S),
OreLocalization.oreDivSMulChar' r₁ r₂ s₁ s₂ = ⟨OreLocalization.oreNum r₁ s₂, ⟨OreLocalization.oreDenom r₁ s₂, ⋯⟩⟩ | true |
Lean.Elab.Tactic.ElabSimpArgsResult | Lean.Elab.Tactic.Simp | Type | true |
Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef.mk._flat_ctor | Lean.Meta.LazyDiscrTree | {α : Type} → IO.Ref (Lean.Meta.LazyDiscrTree α) → Lean.Meta.LazyDiscrTree.ModuleDiscrTreeRef α | false |
MvPolynomial.zeroLocus_bot | 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},
MvPolynomial.zeroLocus K ⊥ = ⊤ | true |
CategoryTheory.Limits.CatCospanTransform.comp_whiskerLeft_assoc | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.CatCospanTransform | ∀ {A : Type u₁} {B : Type u₂} {C : Type u₃} {A' : Type u₄} {B' : Type u₅} {C' : Type u₆} {A'' : Type u₇} {B'' : Type u₈}
{C'' : Type u₉} [inst : CategoryTheory.Category.{v₁, u₁} A] [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] {F : CategoryTheory.Functor A B} {G : Categ... | true |
Nat.div_left_inj._simp_1 | Init.Data.Nat.Lemmas | ∀ {a b d : ℕ}, d ∣ a → d ∣ b → (a / d = b / d) = (a = b) | false |
RingCon.subsingleton_iff | Mathlib.RingTheory.Congruence.Basic | ∀ {R : Type u_3} [inst : Add R] [inst_1 : Mul R], Subsingleton (RingCon R) ↔ Subsingleton R | true |
Filter.biInter_finset_mem | Mathlib.Order.Filter.Finite | ∀ {α : Type u} {f : Filter α} {β : Type v} {s : β → Set α} (is : Finset β), ⋂ i ∈ is, s i ∈ f ↔ ∀ i ∈ is, s i ∈ f | true |
CompleteBooleanAlgebra.mk | Mathlib.Order.CompleteBooleanAlgebra | {α : Type u_1} →
[toCompleteLattice : CompleteLattice α] →
(∀ (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z) →
[toCompl : Compl α] →
[toSDiff : SDiff α] →
[toHImp : HImp α] →
(∀ (x : α), x ⊓ xᶜ ≤ ⊥) →
(∀ (x : α), ⊤ ≤ x ⊔ xᶜ) →
autoParam (∀ (x y : α), ... | true |
Graded.equiv | Mathlib.Data.FunLike.Graded | {E : Type u_1} →
{A : Type u_2} →
{B : Type u_3} →
{σ : Type u_4} →
{τ : Type u_5} →
{ι : Type u_6} →
[inst : SetLike σ A] →
[inst_1 : SetLike τ B] →
{𝒜 : ι → σ} →
{ℬ : ι → τ} → [inst_2 : EquivLike E A B] → [GradedEquivLike E 𝒜 ... | true |
List.instInterOfBEq_batteries | Batteries.Data.List.Basic | {α : Type u_1} → [BEq α] → Inter (List α) | true |
Lean.Meta.Simp.Context.simpTheorems._default | Lean.Meta.Tactic.Simp.Types | Lean.Meta.SimpTheoremsArray | false |
_private.Init.Data.BitVec.Lemmas.0.BitVec.setWidth_ofNat_of_le_of_lt._proof_1_1 | Init.Data.BitVec.Lemmas | ∀ {w v x : ℕ}, ¬1 < 2 → False | false |
LinearMap.range_toContinuousLinearMap | Mathlib.Topology.Algebra.Module.FiniteDimension | ∀ {𝕜 : Type u} [hnorm : NontriviallyNormedField 𝕜] {E : Type v} [inst : AddCommGroup E] [inst_1 : Module 𝕜 E]
[inst_2 : TopologicalSpace E] [inst_3 : IsTopologicalAddGroup E] [inst_4 : ContinuousSMul 𝕜 E] {F' : Type x}
[inst_5 : AddCommGroup F'] [inst_6 : Module 𝕜 F'] [inst_7 : TopologicalSpace F'] [inst_8 : I... | true |
Int.gcd_mul_lcm | Init.Data.Int.Gcd | ∀ (m n : ℤ), m.gcd n * m.lcm n = m.natAbs * n.natAbs | true |
RelEmbedding.natLT._proof_2 | Mathlib.Order.OrderIsoNat | ∀ {α : Type u_1} {r : α → α → Prop} [IsStrictOrder α r] (f : ℕ → α),
(∀ (n : ℕ), r (f n) (f (n + 1))) → ∀ ⦃a b : ℕ⦄, a < b → r (f a) (f b) | false |
CategoryTheory.Limits.isoZeroBiprod_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero X),
(CategoryTheory.Limits.isoZeroBiprod hY).inv = CategoryTheory.Limits.biprod.snd | true |
CategoryTheory.NatIso.pi._proof_2 | Mathlib.CategoryTheory.Pi.Basic | ∀ {I : Type u_3} {C : I → Type u_1} [inst : (i : I) → CategoryTheory.Category.{u_5, u_1} (C i)] {D : I → Type u_4}
[inst_1 : (i : I) → CategoryTheory.Category.{u_2, u_4} (D i)] {F G : (i : I) → CategoryTheory.Functor (C i) (D i)}
(e : (i : I) → F i ≅ G i),
CategoryTheory.CategoryStruct.comp (CategoryTheory.NatTra... | false |
Batteries.mkHashMap | Batteries.Data.HashMap.Basic | {α : Type u_1} → {β : Type u_2} → [inst : BEq α] → [inst_1 : Hashable α] → optParam ℕ 0 → Batteries.HashMap α β | true |
Action.FunctorCategoryEquivalence.unitIso_inv_app_hom | Mathlib.CategoryTheory.Action.Basic | ∀ {V : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} V] {G : Type u_2} [inst_1 : Monoid G] (X : Action V G),
(Action.FunctorCategoryEquivalence.unitIso.inv.app X).hom = CategoryTheory.CategoryStruct.id X.V | true |
_private.Std.Data.DTreeMap.Internal.Queries.0.Std.DTreeMap.Internal.Impl.Const.minEntry.match_1._arg_pusher | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u_1} {β : Type u_2} (motive : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → Sort u_3)
(α_1 : Sort u✝) (β_1 : α_1 → Sort v✝) (f : (x : α_1) → β_1 x)
(rel : (x : Std.DTreeMap.Internal.Impl α fun x => β) → x.isEmpty = false → α_1 → Prop)
(x : Std.DTreeMap.Internal.Impl α fun x => β)... | false |
_private.Mathlib.MeasureTheory.Integral.TorusIntegral.0.term___ | Mathlib.MeasureTheory.Integral.TorusIntegral | Lean.TrailingParserDescr | true |
CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app | Mathlib.CategoryTheory.Triangulated.Opposite.OpOp | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.HasShift C ℤ] (X : Cᵒᵖᵒᵖ)
(n m : ℤ) (hnm : autoParam (n + m = 0) CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso_inv_app._auto_1),
(CategoryTheory.Pretriangulated.Opposite.UnopUnopCommShift.iso C n).inv.app X =
... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.