name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
ne_zero_of_map | Mathlib.Algebra.Group.Hom.Defs | ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
[ZeroHomClass F R S] {f : F} {x : R}, f x ≠ 0 → x ≠ 0 | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ne_intMin_of_msb_eq_false._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, 0 < w → w = 0 → False | false |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.coe_closure_eq._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (M : Subsemigroup R),
AddSubmonoid.closure ↑M = M.nonUnitalSubsemiringClosure.toAddSubmonoid | false |
Matrix.parabolicEigenvalue._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | (1 + 1).AtLeastTwo | false |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_mean_remainder_cauchy._simp_1_7 | Mathlib.Analysis.Calculus.Taylor | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
USize.ofNatLT | Init.Prelude | (n : ℕ) → n < USize.size → USize | true |
convexHull_eq_iInter | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) s = ⋂ t, ⋂ (_ : s ⊆ t), ⋂ (_ : Convex 𝕜 t), t | true |
SSet.horn.primitiveTriangle._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, ∀ k < n + 2, k < n + 3 + 1 | false |
Batteries.Random.MersenneTwister.State.mk.injEq | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (data : Vector (BitVec cfg.wordSize) cfg.stateSize)
(index : Fin cfg.stateSize) (data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize) (index_1 : Fin cfg.stateSize),
({ data := data, index := index } = { data := data_1, index := index_1 }) = (data = data_1 ∧ index = ... | true |
CategoryTheory.ihom.ev_coev_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
[inst_2 : CategoryTheory.Closed A] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj A B ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((Ca... | true |
_private.Mathlib.Data.Multiset.Bind.0.Multiset.nodup_bind._simp_1_1 | Mathlib.Data.Multiset.Bind | ∀ {α : Type u} {β : Type v} {l₁ : List α} {f : α → List β},
(List.flatMap f l₁).Nodup = ((∀ x ∈ l₁, (f x).Nodup) ∧ List.Pairwise (Function.onFun List.Disjoint f) l₁) | false |
MeasureTheory.IsStoppingTime.measurableSpace.congr_simp | Mathlib.Probability.Martingale.OptionalSampling | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f f_1 : MeasureTheory.Filtration ι m}
(e_f : f = f_1) {τ τ_1 : Ω → WithTop ι} (e_τ : τ = τ_1) (hτ : MeasureTheory.IsStoppingTime f τ),
hτ.measurableSpace = ⋯.measurableSpace | true |
CategoryTheory.Functor.PushoutObjObj.mapArrowRight_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {C₁ : Type u₁} {C₂ : Type u₂} {C₃ : Type u₃} [inst : CategoryTheory.Category.{v₁, u₁} C₁]
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] [inst_2 : CategoryTheory.Category.{v₃, u₃} C₃]
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.Arrow C₂}... | true |
_private.Mathlib.GroupTheory.ClassEquation.0.Group.nat_card_center_add_sum_card_noncenter_eq_card._simp_1_6 | Mathlib.GroupTheory.ClassEquation | ∀ {α : Type u} {s : Set α}, (¬s.Nontrivial) = s.Subsingleton | false |
cfc_le_one_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_1... | true |
Set.cast_ncard_sdiff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α} {R : Type u_3} [inst : AddGroupWithOne R],
s ⊆ t → t.Finite → ↑(t \ s).ncard = ↑t.ncard - ↑s.ncard | true |
Lean.Meta.Match.Pattern.applyFVarSubst._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.FVarSubst → Lean.Meta.Match.Pattern → Lean.Meta.Match.Pattern | false |
Function.Injective.addAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x),
Function.Injective.addAction f hf smul = { toVAdd := inst_2, add_vadd := ⋯, zero_vadd := ⋯ } | true |
Subring.toNonUnitalSubring | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} → [inst : NonAssocRing R] → Subring R → NonUnitalSubring R | true |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.deriv2_qaryEntropy._simp_1_3 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | false |
Sym.cast._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ} (h : n = m), Function.LeftInverse (fun s => ⟨↑s, ⋯⟩) fun s => ⟨↑s, ⋯⟩ | false |
Submodule.starProjection_inner_eq_zero | 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] (v w : E), w ∈ K → inner 𝕜 (v - K.starProjection v) w = 0 | true |
Std.DHashMap.diff | Std.Data.DHashMap.Basic | {α : Type u} →
{β : α → Type v} → [inst : BEq α] → [inst_1 : Hashable α] → Std.DHashMap α β → Std.DHashMap α β → Std.DHashMap α β | true |
Turing.TM1to0.trAux.eq_6 | Mathlib.Computability.TuringMachine.PostTuringMachine | ∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (M : Λ → Turing.TM1.Stmt Γ Λ σ) (s : Γ) (x : σ),
Turing.TM1to0.trAux M s Turing.TM1.Stmt.halt x = ((none, x), Turing.TM0.Stmt.write s) | true |
MonomialOrder.div_set | Mathlib.RingTheory.MvPolynomial.Groebner | ∀ {σ : Type u_1} {m : MonomialOrder σ} {R : Type u_2} [inst : CommRing R] {B : Set (MvPolynomial σ R)},
(∀ b ∈ B, IsUnit (m.leadingCoeff b)) →
∀ (f : MvPolynomial σ R),
∃ g r,
f = (Finsupp.linearCombination (MvPolynomial σ R) fun b => ↑b) g + r ∧
(∀ (b : ↑B), m.toSyn (m.degree (↑b * g b)) ... | true |
_private.Lean.Elab.DocString.Builtin.Keywords.0.Lean.Doc.kwImpl.makeHint.match_1 | Lean.Elab.DocString.Builtin.Keywords | (motive : Option Lean.Syntax.Range → Sort u_1) →
(range? : Option Lean.Syntax.Range) →
((b e : String.Pos.Raw) → motive (some { start := b, stop := e })) →
((x : Option Lean.Syntax.Range) → motive x) → motive range? | false |
AdjoinRoot.instGroupWithZero._proof_8 | Mathlib.RingTheory.AdjoinRoot | ∀ {K : Type u_1} [inst : Field K] {f : Polynomial K}, (Ideal.span {f}).IsTwoSided | false |
Lean.Widget.DiffTag.ctorElimType | Lean.Widget.InteractiveCode | {motive : Lean.Widget.DiffTag → Sort u} → ℕ → Sort (max 1 u) | false |
sup_le_of_le_sdiff_left | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a b c : α}, b ≤ c \ a → a ≤ c → a ⊔ b ≤ c | true |
Lean.Grind.Linarith.Expr.denote | Init.Grind.Ordered.Linarith | {α : Type u_1} → [Lean.Grind.IntModule α] → Lean.Grind.Linarith.Context α → Lean.Grind.Linarith.Expr → α | true |
CategoryTheory.Limits.isLimitConeUnopOfCocone_lift | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} J]
(F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ) {c : CategoryTheory.Limits.Cocone F} (hc : CategoryTheory.Limits.IsColimit c)
(s : CategoryTheory.Limits.Cone F.unop),
(CategoryTheory.Limits.isLimitConeUnop... | true |
Finset.card_neg_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Neg α] {s : Finset α}, (-s).card ≤ s.card | true |
Lean.Server.lookupStatefulLspRequestHandler | Lean.Server.Requests | String → BaseIO (Option Lean.Server.StatefulRequestHandler) | true |
_private.Mathlib.Topology.MetricSpace.PiNat.0.PiNat.firstDiff_comm._simp_1_1 | Mathlib.Topology.MetricSpace.PiNat | ∀ {α : Sort u_1} {a b : α}, (a ≠ b) = (b ≠ a) | false |
Std.Do.SPred.bientails.eq_1 | Std.Do.SPred.Laws | ∀ (P_2 Q_2 : Std.Do.SPred []), (P_2 ⊣⊢ₛ Q_2) = (P_2.down ↔ Q_2.down) | true |
Lean.SerialMessage.casesOn | Lean.Message | {motive : Lean.SerialMessage → Sort u} →
(t : Lean.SerialMessage) →
((toBaseMessage : Lean.BaseMessage String) →
(kind : Lean.Name) → motive { toBaseMessage := toBaseMessage, kind := kind }) →
motive t | false |
_private.Mathlib.Data.List.TakeDrop.0.List.span.loop_eq_take_drop | Mathlib.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (l₁ l₂ : List α),
List.span.loop p l₁ l₂ = (l₂.reverse ++ List.takeWhile p l₁, List.dropWhile p l₁) | true |
_private.Mathlib.Data.Finset.Filter.0.Finset.filter_nonempty_iff._simp_1_4 | Mathlib.Data.Finset.Filter | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | false |
ContinuousMap.instCStarAlgebra._proof_1 | Mathlib.Analysis.CStarAlgebra.ContinuousMap | ∀ {A : Type u_1} [inst : CStarAlgebra A], IsTopologicalSemiring A | false |
Stream'.WSeq.bind_assoc._simp_1 | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} {γ : Type w} (s : Stream'.WSeq α) (f : α → Stream'.WSeq β) (g : β → Stream'.WSeq γ),
((s.bind f).bind g ~ʷ s.bind fun x => (f x).bind g) = True | false |
Function.End.mul_def | Mathlib.Algebra.Group.Action.End | ∀ {α : Type u_5} (f g : Function.End α), f * g = f ∘ g | true |
Aesop.CompleteMatch.mk.inj | Aesop.Forward.Match.Types | ∀ {clusterMatches clusterMatches_1 : Array Aesop.Match},
{ clusterMatches := clusterMatches } = { clusterMatches := clusterMatches_1 } → clusterMatches = clusterMatches_1 | true |
Std.Time.ValidDate | Std.Time.Date.ValidDate | Bool → Type | true |
IncidenceAlgebra.ext | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_2} {α : Type u_5} [inst : Zero 𝕜] [inst_1 : LE α] ⦃f g : IncidenceAlgebra 𝕜 α⦄,
(∀ (a b : α), a ≤ b → f a b = g a b) → f = g | true |
tensorKaehlerQuotKerSqEquiv._proof_4 | Mathlib.RingTheory.Smooth.Kaehler | ∀ (P : Type u_1) (S : Type u_2) [inst : CommRing P] [inst_1 : CommRing S] [inst_2 : Algebra P S],
SMulCommClass (P ⧸ RingHom.ker (algebraMap P S) ^ 2) S S | false |
invOf_eq_left_inv | Mathlib.Algebra.Group.Invertible.Defs | ∀ {α : Type u} [inst : Monoid α] {a b : α} [inst_1 : Invertible a], b * a = 1 → ⅟a = b | true |
CategoryTheory.Oplax.StrongTrans.whiskerRight_naturality_naturality_app | Mathlib.CategoryTheory.Bicategory.NaturalTransformation.Oplax | ∀ {B : Type u_1} [inst : CategoryTheory.Bicategory B] {F G : CategoryTheory.OplaxFunctor B CategoryTheory.Cat}
(η : CategoryTheory.Oplax.StrongTrans F G) {a b : B} {a' : CategoryTheory.Cat} {f g : a ⟶ b} (β : f ⟶ g)
(h : G.obj b ⟶ a') (X : ↑(F.obj a)),
CategoryTheory.CategoryStruct.comp (h.toFunctor.map ((η.app b... | true |
_private.Std.Time.Format.Basic.0.Std.Time.instReprText.repr.match_1 | Std.Time.Format.Basic | (motive : Std.Time.Text → Sort u_1) →
(x : Std.Time.Text) →
(Unit → motive Std.Time.Text.short) →
(Unit → motive Std.Time.Text.full) → (Unit → motive Std.Time.Text.narrow) → motive x | false |
CategoryTheory.Comon.MonOpOpToComonObj | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] → CategoryTheory.Mon Cᵒᵖ → CategoryTheory.Comon C | true |
Std.ExtTreeSet.isSome_min?_of_isSome_min?_erase | Std.Data.ExtTreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeSet α cmp} [inst : Std.TransCmp cmp] {k : α},
(t.erase k).min?.isSome = true → t.min?.isSome = true | true |
TensorProduct.AlgebraTensorModule.map_tmul | Mathlib.LinearAlgebra.TensorProduct.Tower | ∀ {R : Type uR} {A : Type uA} {M : Type uM} {N : Type uN} {P : Type uP} {Q : Type uQ} [inst : CommSemiring R]
[inst_1 : Semiring A] [inst_2 : Algebra R A] [inst_3 : AddCommMonoid M] [inst_4 : Module R M] [inst_5 : Module A M]
[inst_6 : IsScalarTower R A M] [inst_7 : AddCommMonoid N] [inst_8 : Module R N] [inst_9 : ... | true |
Set.encard_le_encard_iff_encard_diff_le_encard_diff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, (s ∩ t).Finite → (s.encard ≤ t.encard ↔ (s \ t).encard ≤ (t \ s).encard) | true |
Set.infs_subset_iff | Mathlib.Data.Set.Sups | ∀ {α : Type u_2} [inst : SemilatticeInf α] {s t u : Set α}, s ⊼ t ⊆ u ↔ ∀ a ∈ s, ∀ b ∈ t, a ⊓ b ∈ u | true |
_private.Mathlib.Geometry.Euclidean.Angle.Oriented.Basic.0.Orientation.oangle_smul_add_right_eq_zero_or_eq_pi_iff._simp_1_3 | Mathlib.Geometry.Euclidean.Angle.Oriented.Basic | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} [inst : Ring R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
{v : ι → M} [inst_3 : Fintype ι], (¬LinearIndependent R v) = ∃ g, ∑ i, g i • v i = 0 ∧ ∃ i, g i ≠ 0 | false |
ContinuousAlgEquiv.image_symm_eq_preimage | 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] (e : A ≃A[R] B) (S : Set B), ⇑e.symm '' S = ⇑e ⁻¹' S | true |
DoubleCentralizer.instInhabited | Mathlib.Analysis.CStarAlgebra.Multiplier | {𝕜 : Type u_1} →
{A : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NonUnitalNormedRing A] →
[inst_2 : NormedSpace 𝕜 A] →
[inst_3 : SMulCommClass 𝕜 A A] → [inst_4 : IsScalarTower 𝕜 A A] → Inhabited (DoubleCentralizer 𝕜 A) | true |
_private.Lean.Compiler.LCNF.InferBorrow.0.Lean.Compiler.LCNF.ParamMap.Key.noConfusion | Lean.Compiler.LCNF.InferBorrow | {P : Sort u} →
{t t' : Lean.Compiler.LCNF.ParamMap.Key✝} → t = t' → Lean.Compiler.LCNF.ParamMap.Key.noConfusionType✝ P t t' | false |
_private.Mathlib.RingTheory.Adjoin.Basic.0.Subalgebra.adjoin_eq_span_basis._simp_1_1 | Mathlib.RingTheory.Adjoin.Basic | ∀ {α : Type u_1} {β : Type u_2} {ι : Sort u_4} (g : α → β) (f : ι → α), g '' Set.range f = Set.range (g ∘ f) | false |
CategoryTheory.Cat.HasLimits.limitCone._proof_2 | Mathlib.CategoryTheory.Category.Cat.Limit | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CategoryTheory.Cat) (j : J)
(X : CategoryTheory.Limits.limit (F.comp CategoryTheory.Cat.objects)),
CategoryTheory.Limits.limit.π (CategoryTheory.Cat.HasLimits.homDiagram X X) j (CategoryTheory.CategoryStruct.id X) =
CategoryT... | false |
_private.Init.Data.SInt.Bitwise.0.Int8.or_eq_zero_iff._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | false |
Std.DTreeMap.Internal.Impl.Const.alter._sunfold | Std.Data.DTreeMap.Internal.Operations | {α : Type u} →
{β : Type v} →
[Ord α] →
α →
(Option β → Option β) →
(t : Std.DTreeMap.Internal.Impl α fun x => β) →
t.Balanced → Std.DTreeMap.Internal.Impl.SizedBalancedTree α (fun x => β) (t.size - 1) (t.size + 1) | false |
boolRingCatEquivBoolAlg | Mathlib.Algebra.Category.BoolRing | BoolRing ≌ BoolAlg | true |
_private.Lean.Elab.Util.0.Lean.Elab.getBetterRef.match_1 | Lean.Elab.Util | (motive : Option Lean.Elab.MacroStackElem → Sort u_1) →
(x : Option Lean.Elab.MacroStackElem) →
((elem : Lean.Elab.MacroStackElem) → motive (some elem)) → (Unit → motive none) → motive x | false |
Fin.div_val | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (a b : Fin n), ↑(a / b) = ↑a / ↑b | true |
EuclideanSpace.inner_eq_star_dotProduct | Mathlib.Analysis.InnerProductSpace.PiL2 | ∀ {ι : Type u_1} {𝕜 : Type u_3} [inst : RCLike 𝕜] [inst_1 : Fintype ι] (x y : EuclideanSpace 𝕜 ι),
inner 𝕜 x y = y.ofLp ⬝ᵥ star x.ofLp | true |
AlgebraicGeometry.Scheme.fromSpecResidueField | Mathlib.AlgebraicGeometry.ResidueField | (X : AlgebraicGeometry.Scheme) → (x : ↥X) → AlgebraicGeometry.Spec (X.residueField x) ⟶ X | true |
_private.Mathlib.SetTheory.Ordinal.Veblen.0.Ordinal.cmp_veblenWith.match_1.eq_1 | Mathlib.SetTheory.Ordinal.Veblen | ∀ (motive : Ordering → Sort u_1) (h_1 : Unit → motive Ordering.eq) (h_2 : Unit → motive Ordering.lt)
(h_3 : Unit → motive Ordering.gt),
(match Ordering.eq with
| Ordering.eq => h_1 ()
| Ordering.lt => h_2 ()
| Ordering.gt => h_3 ()) =
h_1 () | true |
_private.Mathlib.Analysis.Complex.PhragmenLindelof.0.PhragmenLindelof.eqOn_right_half_plane_of_superexponential_decay._simp_1_1 | Mathlib.Analysis.Complex.PhragmenLindelof | ∀ {G : Type u_3} [inst : AddGroup G] {a b : G}, (a - b = 0) = (a = b) | false |
MvPowerSeries.support_truncFinset_subset | Mathlib.RingTheory.MvPowerSeries.Trunc | ∀ {σ : Type u_1} {R : Type u_2} [inst : CommSemiring R] {s : Finset (σ →₀ ℕ)} (p : MvPowerSeries σ R),
((MvPowerSeries.truncFinset R s) p).support ⊆ s | true |
inf_le_inf | Mathlib.Order.Lattice | ∀ {α : Type u} [inst : SemilatticeInf α] {a b c d : α}, b ≤ a → d ≤ c → b ⊓ d ≤ a ⊓ c | true |
_private.Mathlib.RingTheory.Norm.Transitivity.0.Algebra.Norm.Transitivity.auxMat_blockTriangular._simp_1_2 | Mathlib.RingTheory.Norm.Transitivity | ∀ {a b : Prop}, (¬(a → b)) = (a ∧ ¬b) | false |
IsCompact.isSigmaCompact | Mathlib.Topology.Compactness.SigmaCompact | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsCompact s → IsSigmaCompact s | true |
List.alternatingProd_cons_cons' | Mathlib.Algebra.BigOperators.Group.List.Basic | ∀ {G : Type u_7} [inst : One G] [inst_1 : Mul G] [inst_2 : Inv G] (a b : G) (l : List G),
(a :: b :: l).alternatingProd = a * b⁻¹ * l.alternatingProd | true |
AlgebraicGeometry.mono_pushoutSection_of_isCompact_of_flat_left_of_ringHomFlat | Mathlib.AlgebraicGeometry.Morphisms.Flat | ∀ {X Y S T : AlgebraicGeometry.Scheme} {f : T ⟶ S} {g : Y ⟶ X} {iX : X ⟶ S} {iY : Y ⟶ T}
(H : CategoryTheory.IsPullback g iY iX f) {US : S.Opens} {UT : T.Opens} {UX : X.Opens}
(hUST : UT ≤ (TopologicalSpace.Opens.map f.base).obj US) (hUSX : UX ≤ (TopologicalSpace.Opens.map iX.base).obj US)
{UY : Y.Opens} (hUY : U... | true |
HasFDerivWithinAt.of_insert | Mathlib.Analysis.Calculus.FDeriv.Basic | ∀ {𝕜 : 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] {f : E → F} {f' : E →L[𝕜] F} {x : E} {s : Set E} {y : E},
HasFDerivWith... | true |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Stepwise.imp_1eq._simp_1_3 | Init.Grind.Ring.CommSolver | ∀ {M : Type u} [inst : Lean.Grind.AddCommGroup M] {a b : M}, (a - b = 0) = (a = b) | false |
isCompact_setOf_finiteMeasure_le_of_isCompact | Mathlib.MeasureTheory.Measure.Prokhorov | ∀ {E : Type u_1} [inst : MeasurableSpace E] [inst_1 : TopologicalSpace E] [T2Space E] [inst_3 : BorelSpace E]
(C : NNReal) {K : Set E}, IsCompact K → IsCompact {μ | μ.mass ≤ C ∧ μ Kᶜ = 0} | true |
Algebra.algebraMapSubmonoid_self | Mathlib.Algebra.Algebra.Basic | ∀ {R : Type u_1} [inst : CommSemiring R] (M : Submonoid R), Algebra.algebraMapSubmonoid R M = M | true |
_private.Mathlib.CategoryTheory.Monoidal.Mon_.0.CategoryTheory.Functor.FullyFaithful.monObj._simp_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {inst_1 : CategoryTheory.MonoidalCategory C} {D : Type u₂}
{inst_2 : CategoryTheory.Category.{v₂, u₂} D} {inst_3 : CategoryTheory.MonoidalCategory D}
(F : CategoryTheory.Functor C D) [self : F.OplaxMonoidal] {X Y : C} (f : X ⟶ Y) (X' : C) {Z : D}
(h : Ca... | false |
CategoryTheory.Abelian.SpectralObject.shortComplexMap._proof_26 | Mathlib.Algebra.Homology.SpectralObject.Page | ∀ {C : Type u_2} {ι : Type u_4} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 : CategoryTheory.Category.{u_3, u_4} ι] [inst_2 : CategoryTheory.Abelian C]
(X : CategoryTheory.Abelian.SpectralObject C ι) {i j k l : ι} (f₁ : i ⟶ j) (f₂ : j ⟶ k) (f₃ : k ⟶ l) {i' j' k' l' : ι}
(f₁' : i' ⟶ j') (f₂' : j' ⟶ k') (... | false |
Lean.instInhabitedVersoDocString.default | Lean.DocString.Extension | Lean.VersoDocString | true |
CategoryTheory.Limits.ImageFactorisation.mk | Mathlib.CategoryTheory.Limits.Shapes.Images | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} →
{f : X ⟶ Y} →
(F : CategoryTheory.Limits.MonoFactorisation f) →
CategoryTheory.Limits.IsImage F → CategoryTheory.Limits.ImageFactorisation f | true |
AddSubmonoid.pi | Mathlib.Algebra.Group.Submonoid.Operations | {ι : Type u_4} →
{M : ι → Type u_5} →
[inst : (i : ι) → AddZeroClass (M i)] → Set ι → ((i : ι) → AddSubmonoid (M i)) → AddSubmonoid ((i : ι) → M i) | true |
_private.Mathlib.Algebra.Order.BigOperators.GroupWithZero.List.0.List.one_le_prod._simp_1_2 | Mathlib.Algebra.Order.BigOperators.GroupWithZero.List | ∀ {α : Sort u_1} {p q : α → Prop} {a' : α}, (∀ (a : α), a = a' ∨ q a → p a) = (p a' ∧ ∀ (a : α), q a → p a) | false |
Lean.Meta.Simp.NormCastConfig.beta._default | Init.MetaTypes | Bool | false |
DiscreteMeasurableSpace.toMeasurableSub | Mathlib.MeasureTheory.Group.Arithmetic | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : Sub α] [DiscreteMeasurableSpace α], MeasurableSub α | true |
FundamentalGroupoid.map_obj_as | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] (f : C(X, Y))
(x : FundamentalGroupoid X), ((FundamentalGroupoid.map f).obj x).as = f x.as | true |
ContinuousLinearMap.toNormedRing._proof_14 | Mathlib.Analysis.Normed.Operator.NormedSpace | ∀ {𝕜 : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NontriviallyNormedField 𝕜]
[inst_2 : NormedSpace 𝕜 E] (a b : E →L[𝕜] E), a - b = a + -b | false |
Option.merge_eq_some_iff | Init.Data.Option.Lemmas | ∀ {α : Type u_1} {o o' : Option α} {f : α → α → α} {a : α},
Option.merge f o o' = some a ↔
o = some a ∧ o' = none ∨ o = none ∧ o' = some a ∨ ∃ b c, o = some b ∧ o' = some c ∧ f b c = a | true |
GrpWithZero.groupWithZeroConcreteCategory._proof_3 | Mathlib.Algebra.Category.GrpWithZero | ∀ {X : GrpWithZero} (x : X.carrier), (CategoryTheory.CategoryStruct.id X) x = x | false |
AlgebraicGeometry.PresheafedSpace.stalkMap.congr_hom | Mathlib.Geometry.RingedSpace.Stalks | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasColimits C]
{X Y : AlgebraicGeometry.PresheafedSpace C} (α β : X ⟶ Y) (h : α = β) (x : ↑↑X),
AlgebraicGeometry.PresheafedSpace.Hom.stalkMap α x =
CategoryTheory.CategoryStruct.comp (CategoryTheory.eqToHom ⋯) (AlgebraicGe... | true |
MulAlgebraNorm.noConfusionType | Mathlib.Analysis.Normed.Unbundled.AlgebraNorm | Sort u →
{R : Type u_1} →
[inst : SeminormedCommRing R] →
{S : Type u_2} →
[inst_1 : Ring S] →
[inst_2 : Algebra R S] →
MulAlgebraNorm R S →
{R' : Type u_1} →
[inst' : SeminormedCommRing R'] →
{S' : Type u_2} → [inst'_1 : Ring S']... | false |
_private.Mathlib.Topology.EMetricSpace.Lipschitz.0.continuousOn_prod_of_subset_closure_continuousOn_lipschitzOnWith.match_1_1 | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u_1} {β : Type u_2} (motive : α × β → Prop) (h : α × β), (∀ (a : α) (b : β), motive (a, b)) → motive h | false |
AlgebraicGeometry.Scheme.map_basicOpen | Mathlib.AlgebraicGeometry.Restrict | ∀ {X : AlgebraicGeometry.Scheme} (U : X.Opens) (r : ↑((↑U).presheaf.obj (Opposite.op ⊤))),
(AlgebraicGeometry.Scheme.Hom.opensFunctor U.ι).obj ((↑U).basicOpen r) =
X.basicOpen ((CategoryTheory.ConcreteCategory.hom (X.presheaf.map (CategoryTheory.eqToHom ⋯).op)) r) | true |
Nat.instTransLe | Init.Data.Nat.Basic | Trans (fun x1 x2 => x1 ≤ x2) (fun x1 x2 => x1 ≤ x2) fun x1 x2 => x1 ≤ x2 | true |
SchwartzMap.fderivCLM._proof_7 | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | ∀ (F : Type u_1) [inst : NormedAddCommGroup F], ContinuousAdd F | false |
CategoryTheory.Limits.isBilimitOfIsLimit._proof_1 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {J : Type u_3}
[inst_2 : Fintype J] {f : J → C} (t : CategoryTheory.Limits.Bicone f) (j : CategoryTheory.Discrete J),
CategoryTheory.CategoryStruct.comp (∑ j, CategoryTheory.CategoryStruct.comp (t.π j) (t.ι j)) (t... | false |
Nat.Prime.mem_primeFactors | Mathlib.Data.Nat.PrimeFin | ∀ {n p : ℕ}, Nat.Prime p → p ∣ n → n ≠ 0 → p ∈ n.primeFactors | true |
trapezoidal_integral | Mathlib.MeasureTheory.Integral.IntervalIntegral.TrapezoidalRule | (ℝ → ℝ) → ℕ → ℝ → ℝ → ℝ | true |
Orientation.kahler_rotation_left' | Mathlib.Geometry.Euclidean.Angle.Oriented.Rotation | ∀ {V : Type u_1} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : Fact (Module.finrank ℝ V = 2)]
(o : Orientation ℝ V (Fin 2)) (x y : V) (θ : Real.Angle),
(o.kahler ((o.rotation θ) x)) y = ↑(-θ).toCircle * (o.kahler x) y | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.