name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
TopologicalSpace.Opens.map_id_obj | Mathlib.Topology.Category.TopCat.Opens | ∀ {X : TopCat} (U : TopologicalSpace.Opens ↑X),
(TopologicalSpace.Opens.map (CategoryTheory.CategoryStruct.id X)).obj U = U | true |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLT.core.nnratArm | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
(lα : Q(LT «$α»)) →
{a b : Q(«$α»)} →
Mathlib.Meta.NormNum.Result a →
Mathlib.Meta.NormNum.Result b →
have e := q(«$a» < «$b»);
Lean.MetaM (Mathlib.Meta.NormNum.Result e) | true |
Std.Internal.IO.Async.Signal.sigttou.elim | Std.Internal.Async.Signal | {motive : Std.Internal.IO.Async.Signal → Sort u} →
(t : Std.Internal.IO.Async.Signal) → t.ctorIdx = 14 → motive Std.Internal.IO.Async.Signal.sigttou → motive t | false |
normSeminorm | Mathlib.Analysis.Seminorm | (𝕜 : Type u_3) →
(E : Type u_7) →
[inst : NormedField 𝕜] → [inst_1 : SeminormedAddCommGroup E] → [inst_2 : NormedSpace 𝕜 E] → Seminorm 𝕜 E | true |
_private.Mathlib.Algebra.GroupWithZero.Basic.0.zero_pow.match_1_1 | Mathlib.Algebra.GroupWithZero.Basic | ∀ (motive : (x : ℕ) → x ≠ 0 → Prop) (x : ℕ) (x_1 : x ≠ 0), (∀ (n : ℕ) (x : n + 1 ≠ 0), motive n.succ x) → motive x x_1 | false |
CategoryTheory.ShortComplex.Splitting.map | Mathlib.Algebra.Homology.ShortComplex.Exact | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
{S : CategoryTheory.ShortComplex C} →
S.Splittin... | true |
Lean.PersistentHashMap.Node.brecOn_3 | Lean.Data.PersistentHashMap | {α : Type u} →
{β : Type v} →
{motive_1 : Lean.PersistentHashMap.Node α β → Sort u_1} →
{motive_2 : Array (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{motive_3 : List (Lean.PersistentHashMap.Entry α β (Lean.PersistentHashMap.Node α β)) → Sort u_1} →
{... | false |
_private.Mathlib.Analysis.InnerProductSpace.Reproducing.0.RKHS.isSelfAdjoint_finsuppSum | Mathlib.Analysis.InnerProductSpace.Reproducing | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {X : Type u_2} {V : Type u_3} [inst_1 : NormedAddCommGroup V]
[inst_2 : InnerProductSpace 𝕜 V] [inst_3 : CompleteSpace V] {K : Matrix X X (V →L[𝕜] V)},
K.IsHermitian → ∀ (f : X →₀ V →L[𝕜] V), IsSelfAdjoint (f.sum fun i xi => f.sum fun j xj => star xi * K i j * xj) | true |
MeasureTheory.L1.SimpleFunc.setToL1SCLM.congr_simp | Mathlib.MeasureTheory.Integral.SetToL1 | ∀ (α : Type u_1) (E : Type u_2) {F : Type u_3} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E]
[inst_2 : NormedAddCommGroup F] [inst_3 : NormedSpace ℝ F] {m : MeasurableSpace α} (μ : MeasureTheory.Measure α)
{T T_1 : Set α → E →L[ℝ] F} (e_T : T = T_1) {C C_1 : ℝ} (e_C : C = C_1)
(hT : MeasureTheory.Domin... | true |
Subgroup.prod_eq_bot_iff._simp_2 | Mathlib.Algebra.Group.Subgroup.Basic | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] {H : Subgroup G} {K : Subgroup N},
(H.prod K = ⊥) = (H = ⊥ ∧ K = ⊥) | false |
specializingMap_iff_isClosed_image_closure_singleton | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f → (SpecializingMap f ↔ ∀ (x : X), IsClosed (f '' closure {x})) | true |
Module.Basis.traceDual_traceDual | Mathlib.RingTheory.Trace.Basic | ∀ {K : Type u_4} {L : Type u_5} [inst : Field K] [inst_1 : Field L] [inst_2 : Algebra K L] {ι : Type w}
[inst_3 : FiniteDimensional K L] [inst_4 : Algebra.IsSeparable K L] [inst_5 : Finite ι] [inst_6 : DecidableEq ι]
(b : Module.Basis ι K L), b.traceDual.traceDual = b | true |
Lean.Meta.Match.Pattern.val.sizeOf_spec | Lean.Meta.Match.Basic | ∀ (e : Lean.Expr), sizeOf (Lean.Meta.Match.Pattern.val e) = 1 + sizeOf e | true |
MeasureTheory.MemLp.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {p q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.MemLp (fun x => (f x).fst) p μ ∧ MeasureTheory.MemLp (fun x => (f x)... | true |
Delone.DeloneSet.mapIsometry_refl | Mathlib.Analysis.AperiodicOrder.Delone.Basic | ∀ {X : Type u_1} [inst : MetricSpace X] (D : Delone.DeloneSet X),
(Delone.DeloneSet.mapIsometry (IsometryEquiv.refl X)) D = D | true |
_private.Lean.Server.FileWorker.WidgetRequests.0.Lean.Widget.TaggedTextHighlightState.mk.inj | Lean.Server.FileWorker.WidgetRequests | ∀ {query : String} {ms : Array String.Pos.Raw} {p : String.Pos.Raw} {anyHighlight : Bool} {query_1 : String}
{ms_1 : Array String.Pos.Raw} {p_1 : String.Pos.Raw} {anyHighlight_1 : Bool},
{ query := query, ms := ms, p := p, anyHighlight := anyHighlight } =
{ query := query_1, ms := ms_1, p := p_1, anyHighlight... | true |
Set.inv_mem_center | Mathlib.Algebra.Group.Center | ∀ {M : Type u_1} [inst : DivisionMonoid M] {a : M}, a ∈ Set.center M → a⁻¹ ∈ Set.center M | true |
QuotientGroup.mulEquivPiModRangePowMonoidHom._proof_1 | Mathlib.GroupTheory.QuotientGroup.Basic | ∀ {ι : Type u_1} (A : ι → Type u_2) [inst : (i : ι) → CommGroup (A i)] (n : ℕ), (fun x => ↑(1 x)) = 1 | false |
MeasureTheory.Measure.pi.isOpenPosMeasure | Mathlib.MeasureTheory.Constructions.Pi | ∀ {ι : Type u_1} {α : ι → Type u_3} [inst : Fintype ι] [inst_1 : (i : ι) → MeasurableSpace (α i)]
(μ : (i : ι) → MeasureTheory.Measure (α i)) [∀ (i : ι), MeasureTheory.SigmaFinite (μ i)]
[inst_3 : (i : ι) → TopologicalSpace (α i)] [∀ (i : ι), (μ i).IsOpenPosMeasure],
(MeasureTheory.Measure.pi μ).IsOpenPosMeasure | true |
LocallyConstant.indicator_of_notMem | Mathlib.Topology.LocallyConstant.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {R : Type u_5} [inst_1 : Zero R] {U : Set X} (f : LocallyConstant X R)
{a : X} (hU : IsClopen U), a ∉ U → (f.indicator hU) a = 0 | true |
Lean.Grind.instCommRingUSize._proof_5 | Init.GrindInstances.Ring.UInt | ∀ (n : ℕ) (a : USize), ↑↑n * a = ↑n * a | false |
_private.Init.Data.BitVec.Bitblast.0.BitVec.msb_srem._proof_1_1 | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {x : BitVec w}, x.toInt < 0 → 0 ≤ x.toInt → False | false |
Lean.Compiler.LCNF.specExtension | Lean.Compiler.LCNF.SpecInfo | Lean.SimplePersistentEnvExtension Lean.Compiler.LCNF.SpecEntry Lean.Compiler.LCNF.SpecState | true |
Bipointed.swapEquiv_functor_map_toFun | Mathlib.CategoryTheory.Category.Bipointed | ∀ {X Y : Bipointed} (f : X ⟶ Y) (a : X.X), (Bipointed.swapEquiv.functor.map f).toFun a = f.toFun a | true |
Batteries.RBNode.foldr.match_1 | Batteries.Data.RBMap.Basic | {α : Type u_1} →
{σ : Sort u_3} →
(motive : Batteries.RBNode α → σ → Sort u_2) →
(x : Batteries.RBNode α) →
(x_1 : σ) →
((b : σ) → motive Batteries.RBNode.nil b) →
((c : Batteries.RBColor) →
(l : Batteries.RBNode α) →
(v : α) → (r : Batteries.R... | false |
Nat.greatestFib.eq_1 | Mathlib.Data.Nat.Fib.Zeckendorf | ∀ (n : ℕ), n.greatestFib = Nat.findGreatest (fun k => Nat.fib k ≤ n) (n + 1) | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.getFieldDefaultValue? | Lean.Elab.Structure | Lean.Name → Array Lean.Expr → Lean.Name → Lean.Elab.Command.Structure.StructElabM✝ (Option Lean.Expr) | true |
surjOn_Icc_of_monotone_surjective | Mathlib.Order.Interval.Set.SurjOn | ∀ {α : Type u_1} {β : Type u_2} [inst : LinearOrder α] [inst_1 : PartialOrder β] {f : α → β},
Monotone f → Function.Surjective f → ∀ {a b : α}, a ≤ b → Set.SurjOn f (Set.Icc a b) (Set.Icc (f a) (f b)) | true |
MeasureTheory.JordanDecomposition.zero_posPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Jordan | ∀ {α : Type u_1} [inst : MeasurableSpace α], MeasureTheory.JordanDecomposition.posPart 0 = 0 | true |
_private.Mathlib.Data.List.Triplewise.0.List.triplewise_iff_getElem._proof_1_14 | Mathlib.Data.List.Triplewise | ∀ {α : Type u_1} (tail : List α) (i j k : ℕ), i < j → j < k → k < tail.length + 1 → i < tail.length | false |
MapClusterPt.prodMap | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {α : Type u_5} {β : Type u_6}
{f : α → X} {g : β → Y} {la : Filter α} {lb : Filter β} {x : X} {y : Y},
MapClusterPt x la f → MapClusterPt y lb g → MapClusterPt (x, y) (la ×ˢ lb) (Prod.map f g) | true |
Std.Tactic.BVDecide.Normalize.BitVec.zero_ult' | Std.Tactic.BVDecide.Normalize.BitVec | ∀ {w : ℕ} (a : BitVec w), (0#w).ult a = !a == 0#w | true |
GroupExtension.Splitting.semidirectProductMulEquiv | Mathlib.GroupTheory.GroupExtension.Basic | {N : Type u_1} →
{G : Type u_2} →
[inst : Group N] →
[inst_1 : Group G] →
{E : Type u_3} → [inst_2 : Group E] → {S : GroupExtension N E G} → (s : S.Splitting) → N ⋊[s.conjAct] G ≃* E | true |
CompTriple.IsId.rec | Mathlib.Logic.Function.CompTypeclasses | {M : Type u_1} →
{σ : M → M} →
{motive : CompTriple.IsId σ → Sort u} → ((eq_id : σ = id) → motive ⋯) → (t : CompTriple.IsId σ) → motive t | false |
_private.Lean.Data.Array.0.Array.mask.match_1 | Lean.Data.Array | {α : Type u_1} →
(motive : Option (α × Subarray α) → Sort u_2) →
(x : Option (α × Subarray α)) →
(Unit → motive none) → ((x : α) → (s' : Subarray α) → motive (some (x, s'))) → motive x | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastShiftLeftConst.go._unary._proof_3 | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftLeft | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (input : aig.RefVec w)
(distance curr : ℕ) (hcurr : curr ≤ w) (s : aig.RefVec curr) (hidx : curr < w) (hdist : ¬curr < distance),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun curr hcurr => PSigma.casesOn hc... | false |
neg_add_cancel_comm_assoc | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddCommGroup G] (a b : G), -a + (b + a) = b | true |
Set.countable_setOf_finite_subset | Mathlib.Data.Set.Countable | ∀ {α : Type u} {s : Set α}, s.Countable → {t | t.Finite ∧ t ⊆ s}.Countable | true |
CategoryTheory.Pi.μ_def | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type w₁} {C : I → Type u₁} [inst : (i : I) → CategoryTheory.Category.{v₁, u₁} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] (i : I) (X Y : (i : I) → C i),
CategoryTheory.Functor.LaxMonoidal.μ (CategoryTheory.Pi.eval C i) X Y =
CategoryTheory.CategoryStruct.id (CategoryTheory.MonoidalC... | true |
IntervalIntegrable.mono_set | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {ε : Type u_3} [inst : TopologicalSpace ε] [inst_1 : ENormedAddMonoid ε] {f : ℝ → ε} {a b c d : ℝ}
{μ : MeasureTheory.Measure ℝ} [TopologicalSpace.PseudoMetrizableSpace ε],
IntervalIntegrable f μ a b → Set.uIcc c d ⊆ Set.uIcc a b → IntervalIntegrable f μ c d | true |
Set.restrict_ite_compl | Mathlib.Data.Set.Restrict | ∀ {α : Type u_1} {β : Type u_2} (f g : α → β) (s : Set α) [inst : (x : α) → Decidable (x ∈ s)],
(sᶜ.restrict fun a => if a ∈ s then f a else g a) = sᶜ.restrict g | true |
CategoryTheory.LocalizerMorphism.IsRightDerivabilityStructure.Constructor.fromRightResolution_map | Mathlib.CategoryTheory.Localization.DerivabilityStructure.Constructor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} [inst : CategoryTheory.Category.{v_1, u_1} C₁]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C₂] {W₁ : CategoryTheory.MorphismProperty C₁}
{W₂ : CategoryTheory.MorphismProperty C₂} (Φ : CategoryTheory.LocalizerMorphism W₁ W₂) {D : Type u_3}
[inst_2 : CategoryTheory.Category.{v_3, ... | true |
descPochhammer_eval_eq_descFactorial | Mathlib.RingTheory.Polynomial.Pochhammer | ∀ (R : Type u) [inst : Ring R] (n k : ℕ), Polynomial.eval (↑n) (descPochhammer R k) = ↑(n.descFactorial k) | true |
ONote.NFBelow | Mathlib.SetTheory.Ordinal.Notation | ONote → Ordinal.{0} → Prop | true |
Units.instDecidableEq | Mathlib.Algebra.Group.Units.Defs | {α : Type u} → [inst : Monoid α] → [DecidableEq α] → DecidableEq αˣ | true |
_private.Mathlib.Analysis.Complex.Convex.0.Complex.instPathConnectedSpaceUnits._simp_3 | Mathlib.Analysis.Complex.Convex | ∀ {a b : Prop}, (¬(a ∧ b)) = (¬a ∨ ¬b) | false |
OneHomClass | Mathlib.Algebra.Group.Hom.Defs | (F : Type u_10) → (M : outParam (Type u_11)) → (N : outParam (Type u_12)) → [One M] → [One N] → [FunLike F M N] → Prop | true |
Std.Do.«term_∧ₚ_» | Std.Do.PostCond | Lean.TrailingParserDescr | true |
R0Space.closure_singleton | Mathlib.Topology.Separation.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] [R0Space X] (x : X), closure {x} = (nhds x).ker | true |
Fin.val_natCast | Mathlib.Data.Fin.Basic | ∀ (a n : ℕ) [inst : NeZero n], ↑↑a = a % n | true |
OneHom.coe_id | Mathlib.Algebra.Group.Hom.Defs | ∀ {M : Type u_10} [inst : One M], ⇑(OneHom.id M) = id | true |
Std.DHashMap.Const.getKey!_unitOfList_of_contains_eq_false | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} [EquivBEq α] [LawfulHashable α] [inst : Inhabited α] {l : List α} {k : α},
l.contains k = false → (Std.DHashMap.Const.unitOfList l).getKey! k = default | true |
Finset.SupIndep.le_sup_iff | Mathlib.Order.SupIndep | ∀ {α : Type u_1} {ι : Type u_3} [inst : Lattice α] [inst_1 : OrderBot α] {s t : Finset ι} {f : ι → α} {i : ι},
s.SupIndep f → t ⊆ s → i ∈ s → (∀ (i : ι), f i ≠ ⊥) → (f i ≤ t.sup f ↔ i ∈ t) | true |
_private.Mathlib.Dynamics.TopologicalEntropy.CoverEntropy.0.Dynamics.nonempty_inter_of_coverMincard._simp_1_1 | Mathlib.Dynamics.TopologicalEntropy.CoverEntropy | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.L1.0.MeasureTheory.SimpleFunc.integral_mono_measure._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.L1 | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] {f : MeasureTheory.SimpleFunc α β} {p : β → Prop},
(∀ y ∈ f.range, p y) = ∀ (x : α), p (f x) | false |
_private.Mathlib.RingTheory.PowerSeries.Derivative.0.PowerSeries.derivativeFun_coe_mul_coe | Mathlib.RingTheory.PowerSeries.Derivative | ∀ {R : Type u_1} [inst : CommSemiring R] (f g : Polynomial R),
(↑f * ↑g).derivativeFun = ↑f * ↑(Polynomial.derivative g) + ↑g * ↑(Polynomial.derivative f) | true |
TensorProduct.LieModule.map._proof_1 | Mathlib.Algebra.Lie.TensorProduct | ∀ {R : Type u_3} [inst : CommRing R] {L : Type u_6} {M : Type u_5} {N : Type u_4} {P : Type u_1} {Q : Type u_2}
[inst_1 : LieRing L] [inst_2 : LieAlgebra R L] [inst_3 : AddCommGroup M] [inst_4 : Module R M]
[inst_5 : LieRingModule L M] [inst_6 : LieModule R L M] [inst_7 : AddCommGroup N] [inst_8 : Module R N]
[in... | false |
_private.Init.Data.String.Lemmas.Pattern.String.ForwardSearcher.0.String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch.isValidForSlice | Init.Data.String.Lemmas.Pattern.String.ForwardSearcher | ∀ {pat s : String.Slice},
pat.isEmpty = false →
∀ {pos : String.Pos.Raw},
String.Slice.Pattern.Model.ForwardSliceSearcher.PartialMatch✝ pat.copy.toByteArray s.copy.toByteArray
pat.utf8ByteSize pos.byteIdx →
String.Pos.Raw.IsValidForSlice s (pos.unoffsetBy pat.rawEndPos) → String.Pos.Raw.Is... | true |
FreeGroup.mulEquivIntOfUnique._proof_2 | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u_1} [inst : Unique α] (x : Multiplicative ℤ),
(⇑Multiplicative.ofAdd ∘ ⇑FreeGroup.equivIntOfUnique) ((⇑FreeGroup.equivIntOfUnique.symm ∘ ⇑Multiplicative.toAdd) x) =
x | false |
ZeroHom.mk.noConfusion | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
{inst : Zero M} →
{inst_1 : Zero N} →
{P : Sort u} →
{toFun : M → N} →
{map_zero' : toFun 0 = 0} →
{toFun' : M → N} →
{map_zero'' : toFun' 0 = 0} →
{ toFun := toFun, map_zero' := map_zero' } = {... | false |
_private.Init.Data.SInt.Lemmas.0.Int8.le_iff_lt_or_eq._simp_1_3 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x < y) = (x.toInt < y.toInt) | false |
_private.Batteries.Data.UnionFind.Basic.0.Batteries.UnionFind.findAux.match_1.splitter | Batteries.Data.UnionFind.Basic | (self : Batteries.UnionFind) →
(motive : Batteries.UnionFind.FindAux self.size → Sort u_1) →
(x : Batteries.UnionFind.FindAux self.size) →
((arr₁ : Array Batteries.UFNode) →
(root : Fin self.size) → (H : arr₁.size = self.size) → motive { s := arr₁, root := root, size_eq := H }) →
motive x | true |
CategoryTheory.WithInitial.equivComma._proof_12 | Mathlib.CategoryTheory.WithTerminal.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_4, u_2} C] {D : Type u_3}
[inst_1 : CategoryTheory.Category.{u_1, u_3} D]
{X Y : CategoryTheory.Comma (CategoryTheory.Functor.const C) (CategoryTheory.Functor.id (CategoryTheory.Functor C D))}
(f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp
(({ obj := Ca... | false |
RatFunc.wrapped._@.Mathlib.FieldTheory.RatFunc.Basic.870781102._hygCtx._hyg.2 | Mathlib.FieldTheory.RatFunc.Basic | Subtype (Eq @RatFunc.definition✝) | false |
Aesop.RuleBuilderOptions.indexingMode? | Aesop.Builder.Basic | Aesop.RuleBuilderOptions → Option Aesop.IndexingMode | true |
Units.inv_mul_of_eq | Mathlib.Algebra.Group.Units.Defs | ∀ {α : Type u} [inst : Monoid α] {u : αˣ} {a : α}, ↑u = a → ↑u⁻¹ * a = 1 | true |
Nonneg.mk_smul | Mathlib.Algebra.Order.Nonneg.Module | ∀ {R : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [inst_2 : SMul R S] (a : R) (ha : 0 ≤ a)
(x : S), ⟨a, ha⟩ • x = a • x | true |
Set.preimage_singleton_eq_empty | Mathlib.Data.Set.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {y : β}, f ⁻¹' {y} = ∅ ↔ y ∉ Set.range f | true |
Set.isSimpleOrder_Iic_iff_isAtom | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, IsSimpleOrder ↑(Set.Iic a) ↔ IsAtom a | true |
CategoryTheory.MonoidalCategory.fullSubcategory._proof_11 | Mathlib.CategoryTheory.Monoidal.Category | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C]
(P : CategoryTheory.ObjectProperty C)
(tensorObj : ∀ (X Y : C), P X → P Y → P (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y))
{X₁ X₂ X₃ Y₁ Y₂ Y₃ : P.FullSubcategory} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (f₃... | false |
_private.Mathlib.RingTheory.MvPowerSeries.Rename.0.MvPowerSeries.killCompl_X._simp_1_1 | Mathlib.RingTheory.MvPowerSeries.Rename | ∀ {α : Type u_1} {β : Type u_2} {M : Type u_5} [inst : Zero M] (f : α ↪ β) (a : α) (m : M),
(fun₀ | f a => m) = Finsupp.embDomain f fun₀ | a => m | false |
Lean.Elab.Tactic.Conv.PatternMatchState.rec | Lean.Elab.Tactic.Conv.Pattern | {motive : Lean.Elab.Tactic.Conv.PatternMatchState → Sort u} →
((subgoals : Array Lean.MVarId) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.all subgoals)) →
((subgoals : Array (ℕ × Lean.MVarId)) →
(idx : ℕ) →
(remaining : List (ℕ × ℕ)) → motive (Lean.Elab.Tactic.Conv.PatternMatchState.occs s... | false |
OrderMonoidHom.inrₗ | Mathlib.Algebra.Order.Monoid.Lex | (α : Type u_1) →
(β : Type u_2) →
[inst : Monoid α] → [inst_1 : PartialOrder α] → [inst_2 : Monoid β] → [inst_3 : Preorder β] → β →*o Lex (α × β) | true |
selfAdjoint.instField._proof_12 | Mathlib.Algebra.Star.SelfAdjoint | ∀ {R : Type u_1} [inst : Field R] [inst_1 : StarRing R] (x : ℤ), ↑↑x = ↑↑x | false |
WithBot.map_zero | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : Zero α] {β : Type u_1} (f : α → β), WithBot.map f 0 = ↑(f 0) | true |
ZeroHom.instModule._proof_1 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_2} {B : Type u_1} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (r : R), r • 0 = 0 | false |
_private.Init.Data.Range.Polymorphic.IntLemmas.0.Int.map_add_toList_rcc._proof_1_1 | Init.Data.Range.Polymorphic.IntLemmas | ∀ {n k : ℤ}, ¬n + 1 + k = n + k + 1 → False | false |
ConvexOn.lt_left_of_right_lt' | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : LinearOrder β] [IsOrderedCancelAddMonoid β] [inst_6 : Module 𝕜 E]
[inst_7 : Module 𝕜 β] [PosSMulStrictMono 𝕜 β] {s : Set E} {f : E → β},
ConvexOn 𝕜 s ... | true |
MonoidAlgebra.mapAlgHom_apply | Mathlib.Algebra.MonoidAlgebra.Basic | ∀ {R : Type u_1} {A : Type u_4} {B : Type u_5} {M : Type u_7} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Semiring B] [inst_3 : Algebra R A] [inst_4 : Algebra R B] [inst_5 : Monoid M] (f : A →ₐ[R] B)
(x : MonoidAlgebra A M) (m : M), ((MonoidAlgebra.mapAlgHom M f) x) m = f (x m) | true |
Except.ctorIdx | Init.Prelude | {ε : Type u} → {α : Type v} → Except ε α → ℕ | false |
_private.Mathlib.Algebra.Divisibility.Prod.0.pi_dvd_iff._simp_1_2 | Mathlib.Algebra.Divisibility.Prod | ∀ {α : Sort u} {β : α → Sort v} {f g : (x : α) → β x}, (f = g) = ∀ (x : α), f x = g x | false |
AlgebraicGeometry.Scheme.basicOpen_le | Mathlib.AlgebraicGeometry.Scheme | ∀ (X : AlgebraicGeometry.Scheme) {U : X.Opens} (f : ↑(X.presheaf.obj (Opposite.op U))), X.basicOpen f ≤ U | true |
CategoryTheory.Precoverage.mem_coverings_of_isIso | Mathlib.CategoryTheory.Sites.Precoverage | ∀ {C : Type u} {inst : CategoryTheory.Category.{v, u} C} {J : CategoryTheory.Precoverage C} [self : J.HasIsos] {S T : C}
(f : S ⟶ T) [CategoryTheory.IsIso f], CategoryTheory.Presieve.singleton f ∈ J.coverings T | true |
Primrec.PrimrecBounded | Mathlib.Computability.Primrec.Basic | {α : Type u_1} → {β : Type u_2} → [Primcodable α] → [Primcodable β] → (α → β) → Prop | true |
Order.Ideal.toLowerSet_injective | Mathlib.Order.Ideal | ∀ {P : Type u_1} [inst : LE P], Function.Injective Order.Ideal.toLowerSet | true |
SimpleGraph.cliqueFinset_eq_empty_iff | Mathlib.Combinatorics.SimpleGraph.Clique | ∀ {α : Type u_1} {G : SimpleGraph α} [inst : Fintype α] [inst_1 : DecidableEq α] [inst_2 : DecidableRel G.Adj] {n : ℕ},
G.cliqueFinset n = ∅ ↔ G.CliqueFree n | true |
LieAlgebra.IsExtension.range_eq_top | Mathlib.Algebra.Lie.Extension | ∀ {R : Type u_1} {N : Type u_2} {L : Type u_3} {M : Type u_4} {inst : CommRing R} {inst_1 : LieRing L}
{inst_2 : LieAlgebra R L} {inst_3 : LieRing N} {inst_4 : LieAlgebra R N} {inst_5 : LieRing M}
{inst_6 : LieAlgebra R M} (i : N →ₗ⁅R⁆ L) {p : L →ₗ⁅R⁆ M} [self : LieAlgebra.IsExtension i p], p.range = ⊤ | true |
CategoryTheory.OverPresheafAux.restrictedYoneda._proof_3 | Mathlib.CategoryTheory.Comma.Presheaf.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] (A : CategoryTheory.Functor Cᵒᵖ (Type u_2))
{X Y : CategoryTheory.Over A} (ε : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Functor.id (CategoryTheory.Functor Cᵒᵖ (Type u_2))).map ε.left)
Y.hom =
CategoryTheory.CategoryStruct.co... | false |
Finset.Colex.toColex_sdiff_lt_toColex_sdiff' | Mathlib.Combinatorics.Colex | ∀ {α : Type u_1} [inst : PartialOrder α] {s t : Finset α} [inst_1 : DecidableEq α],
toColex (s \ t) < toColex (t \ s) ↔ toColex s < toColex t | true |
Lean.Parser.ParserResolution.alias | Lean.Parser.Extension | Lean.Parser.ParserAliasValue → Lean.Parser.ParserResolution | true |
HasSubset.noConfusion | Init.Core | {P : Sort u_1} →
{α : Type u} →
{t : HasSubset α} → {α' : Type u} → {t' : HasSubset α'} → α = α' → t ≍ t' → HasSubset.noConfusionType P t t' | false |
_private.Lean.Meta.LazyDiscrTree.0.Lean.Meta.LazyDiscrTree.blacklistInsertion.match_1 | Lean.Meta.LazyDiscrTree | (motive : Lean.Name → Sort u_1) →
(declName : Lean.Name) → ((pre : Lean.Name) → motive (pre.str "inj")) → ((x : Lean.Name) → motive x) → motive declName | false |
_private.Lean.Compiler.LCNF.Basic.0.Lean.Compiler.LCNF.LetValue.updateArgsImp | Lean.Compiler.LCNF.Basic | {pu : Lean.Compiler.LCNF.Purity} →
Lean.Compiler.LCNF.LetValue pu → Array (Lean.Compiler.LCNF.Arg pu) → Lean.Compiler.LCNF.LetValue pu | true |
CategoryTheory.IsDiscrete.sum | Mathlib.CategoryTheory.Discrete.SumsProducts | ∀ (C : Type u_1) (C' : Type u_2) [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} C'] [CategoryTheory.IsDiscrete C] [CategoryTheory.IsDiscrete C'],
CategoryTheory.IsDiscrete (C ⊕ C') | true |
USize.toNat_sub_of_le | Init.Data.UInt.Lemmas | ∀ (a b : USize), b ≤ a → (a - b).toNat = a.toNat - b.toNat | true |
Lean.Compiler.CSimp.replaceConstant | Lean.Compiler.CSimpAttr | Lean.Environment → Lean.Expr → Lean.CoreM Lean.Expr | true |
_private.Init.Data.Array.BinSearch.0.Array.binSearchAux._proof_3 | Init.Data.Array.BinSearch | ∀ {α : Type u_1} (as : Array α) (lo : Fin (as.size + 1)) (hi : Fin as.size),
↑lo ≤ ↑hi → ¬(↑lo + ↑hi) / 2 < as.size → False | false |
PNat.XgcdType.flip_b | Mathlib.Data.PNat.Xgcd | ∀ (u : PNat.XgcdType), u.flip.b = u.a | true |
Lean.Lsp.LeanIleanInfoParams.recOn | Lean.Data.Lsp.Internal | {motive : Lean.Lsp.LeanIleanInfoParams → Sort u} →
(t : Lean.Lsp.LeanIleanInfoParams) →
((version : ℕ) →
(references : Lean.Lsp.ModuleRefs) →
(decls : Lean.Lsp.Decls) → motive { version := version, references := references, decls := decls }) →
motive t | false |
_private.Init.Grind.Ring.CommSolver.0.Lean.Grind.CommRing.Poly.combine_k_eq_combine._simp_1_8 | Init.Grind.Ring.CommSolver | ∀ (m₁ m₂ : Lean.Grind.CommRing.Mon), m₁.grevlex m₂ = m₁.grevlex_k m₂ | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.