name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
isArtinianRing_iff_isNilpotent_maximalIdeal | Mathlib.RingTheory.HopkinsLevitzki | ∀ (R : Type u_3) [inst : CommRing R] [IsNoetherianRing R] [inst_2 : IsLocalRing R],
IsArtinianRing R ↔ IsNilpotent (IsLocalRing.maximalIdeal R) | true |
_private.Lean.Elab.Declaration.0.Lean.Elab.Command.elabInitialize.match_5 | Lean.Elab.Declaration | (motive : Option (Lean.TSyntax `ident) × Option (Lean.TSyntax `term) → Sort u_1) →
(x : Option (Lean.TSyntax `ident) × Option (Lean.TSyntax `term)) →
((id : Lean.TSyntax `ident) → (type : Lean.TSyntax `term) → motive (some id, some type)) →
((x : Option (Lean.TSyntax `ident) × Option (Lean.TSyntax `term)) →... | false |
Int.shift2 | Mathlib.Data.FP.Basic | ℕ → ℕ → ℤ → ℕ × ℕ | true |
Mathlib.Tactic.TermCongr.mkHEqForExpectedType | Mathlib.Tactic.TermCongr | Option Lean.Expr → Lean.MetaM Lean.Expr | true |
Subalgebra.unop_sSup | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : Set (Subalgebra R Aᵐᵒᵖ)), (sSup S).unop = sSup (Subalgebra.op ⁻¹' S) | true |
Ordinal.type_prod_lex | Mathlib.SetTheory.Ordinal.Arithmetic | ∀ {α β : Type u} (r : α → α → Prop) (s : β → β → Prop) [inst : IsWellOrder α r] [inst_1 : IsWellOrder β s],
Ordinal.type (Prod.Lex s r) = Ordinal.type r * Ordinal.type s | true |
FirstOrder.Language.LHom.onTerm.eq_def | Mathlib.ModelTheory.Syntax | ∀ {L : FirstOrder.Language} {L' : FirstOrder.Language} {α : Type u'} (φ : L →ᴸ L') (x : L.Term α),
φ.onTerm x =
match x with
| FirstOrder.Language.var i => FirstOrder.Language.var i
| FirstOrder.Language.func f ts => FirstOrder.Language.func (φ.onFunction f) fun i => φ.onTerm (ts i) | true |
String.push_induction | Init.Data.String.Basic | ∀ (s : String) (motive : String → Prop),
motive "" → (∀ (b : String) (c : Char), motive b → motive (b.push c)) → motive s | true |
Filter.filter_injOn_Iic_iff_injOn | Mathlib.Order.Filter.Map | ∀ {α : Type u_1} {β : Type u_2} {s : Set α} {m : α → β},
Set.InjOn (Filter.map m) (Set.Iic (Filter.principal s)) ↔ Set.InjOn m s | true |
localizedQuotientEquiv | Mathlib.Algebra.Module.LocalizedModule.Submodule | {R : Type u_5} →
{M : Type u_7} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
(p : Submonoid R) →
(M' : Submodule R M) →
(LocalizedModule p M ⧸ Submodule.localized p M') ≃ₗ[Localization p] LocalizedModule p (M ⧸ M') | true |
_private.Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic.0.vectorSpan_range_eq_span_range_vsub_left_ne._simp_1_5 | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Basic | ∀ {α : Sort u} {p : α → Prop} {q : { a // p a } → Prop}, (∃ x, q x) = ∃ a, ∃ (b : p a), q ⟨a, b⟩ | false |
SchwartzMap.pderivCLM | Mathlib.Analysis.Distribution.SchwartzSpace.Deriv | (R : Type u_4) →
{V : Type u_5} →
(E : Type u_6) →
{F : Type u_7} →
[inst : Ring R] →
[inst_1 : AddCommGroup E] →
[inst_2 : Module R E] →
[inst_3 : AddCommGroup F] →
[inst_4 : Module R F] →
[inst_5 : TopologicalSpace E] →
... | true |
_private.Batteries.Data.List.Basic.0.List.all₂.match_1.splitter | Batteries.Data.List.Basic | {α : Type u_1} →
{β : Type u_2} →
(motive : List α → List β → Sort u_3) →
(x : List α) →
(x_1 : List β) →
(Unit → motive [] []) →
((a : α) → (as : List α) → (b : β) → (bs : List β) → motive (a :: as) (b :: bs)) →
((x : List α) →
(x_2 : List β) →
... | true |
instBooleanAlgebraSubtypeIsIdempotentElem._proof_1 | Mathlib.Algebra.Order.Ring.Idempotent | ∀ {R : Type u_1} [inst : CommRing R] (a b c : { x // IsIdempotentElem x }), ↑(a ⊓ (b ⊔ c)) = ↑(a ⊓ b ⊔ a ⊓ c) | false |
AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal_ideal | Mathlib.AlgebraicGeometry.IdealSheaf.Basic | ∀ {X : AlgebraicGeometry.Scheme} (Z : TopologicalSpace.Closeds ↥X) (U : ↑X.affineOpens),
(AlgebraicGeometry.Scheme.IdealSheafData.vanishingIdeal Z).ideal U =
PrimeSpectrum.vanishingIdeal (⇑(AlgebraicGeometry.IsAffineOpen.fromSpec ⋯) ⁻¹' ↑Z) | true |
Char.reduceIsDigit | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | Lean.Meta.Simp.DSimproc | true |
Std.TreeSet.Raw.instSliceableRooSlice._auto_1 | Std.Data.TreeSet.Raw.Slice | Lean.Syntax | false |
εNFA.εClosure.below | Mathlib.Computability.EpsilonNFA | {α : Type u} →
{σ : Type v} →
{M : εNFA α σ} → {S : Set σ} → {motive : (a : σ) → M.εClosure S a → Prop} → {a : σ} → M.εClosure S a → Prop | true |
ModuleCat.span_rightExact | Mathlib.Algebra.Category.ModuleCat.Free | ∀ {ι : Type u_1} {ι' : Type u_2} {R : Type u_3} [inst : Ring R] {S : CategoryTheory.ShortComplex (ModuleCat R)},
S.Exact →
∀ {v : ι → ↑S.X₁} {w : ι' → ↑S.X₃},
⊤ ≤ Submodule.span R (Set.range v) →
⊤ ≤ Submodule.span R (Set.range w) →
CategoryTheory.Epi S.g →
⊤ ≤
Su... | true |
List.permutations_append | Mathlib.Data.List.Permutation | ∀ {α : Type u_1} (is ts : List α),
(is ++ ts).permutations = List.map (fun x => x ++ ts) is.permutations ++ ts.permutationsAux is.reverse | true |
derivWithin_sub | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {x : 𝕜} {s : Set 𝕜},
DifferentiableWithinAt 𝕜 f s x →
DifferentiableWithinAt 𝕜 g s x → derivWithin (f - g) s x = derivWithin f s x - derivWithin g s x | true |
_private.Lean.DocString.Types.0.Lean.Doc.instOrdPart.ord.match_1 | Lean.DocString.Types | {i : Type u_1} →
{b : Type u_2} →
{p : Type u_3} →
(motive : Lean.Doc.Part i b p → Lean.Doc.Part i b p → Sort u_4) →
(x x_1 : Lean.Doc.Part i b p) →
((a : Array (Lean.Doc.Inline i)) →
(a_1 : String) →
(a_2 : Option p) →
(a_3 : Array (Lean.Doc... | false |
_private.Mathlib.Algebra.Lie.LieTheorem.0.LieModule.weightSpaceOfIsLieTower_aux._simp_1_20 | Mathlib.Algebra.Lie.LieTheorem | ∀ {R : Type v} {M : Type w} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (f : Module.End R M)
(μ : R) (m : M), (m ∈ f.maxGenEigenspace μ) = ∃ k, ((f - μ • 1) ^ k) m = 0 | false |
SimpleGraph.IsMaximumClique.recOn | Mathlib.Combinatorics.SimpleGraph.Clique | {α : Type u_3} →
[inst : Finite α] →
{G : SimpleGraph α} →
{s : Finset α} →
{motive : G.IsMaximumClique s → Sort u} →
(t : G.IsMaximumClique s) →
((isClique : G.IsClique ↑s) → (maximum : ∀ (t : Finset α), G.IsClique ↑t → t.card ≤ s.card) → motive ⋯) →
motive t | false |
HasDerivAt.complexToReal_fderiv | Mathlib.Analysis.Complex.RealDeriv | ∀ {f : ℂ → ℂ} {f' x : ℂ}, HasDerivAt f f' x → HasFDerivAt f (f' • 1) x | true |
Array.mergeAdjacentDups.go | Batteries.Data.Array.Merge | {α : Type u_1} → [eq : BEq α] → (α → α → α) → Array α → Array α → ℕ → α → Array α | true |
CategoryTheory.Pseudofunctor.DescentData.subtypeCompatibleHomEquiv._proof_2 | Mathlib.CategoryTheory.Sites.Descent.DescentData | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {ι : Type u_3} {S : C} {X : ι → C}
(f : (i : ι) → X i ⟶ S) (i : ι),
CategoryTheory.CategoryStruct.comp (f i) (CategoryTheory.Over.mk (CategoryTheory.CategoryStruct.id S)).hom =
((fun i => CategoryTheory.Over.mk (f i)) i).hom | false |
MatrixEquivTensor.right_inv | Mathlib.RingTheory.MatrixAlgebra | ∀ (n : Type u_3) (R : Type u_5) (A : Type u_7) [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
[inst_3 : DecidableEq n] [inst_4 : Fintype n] (M : Matrix n n A),
(MatrixEquivTensor.toFunAlgHom n R A) (MatrixEquivTensor.invFun n R A M) = M | true |
WithTop.coeOrderHom | Mathlib.Order.Hom.WithTopBot | {α : Type u_4} → [inst : Preorder α] → α ↪o WithTop α | true |
convexOn_pow | Mathlib.Analysis.Convex.Mul | ∀ {𝕜 : Type u_1} [inst : CommRing 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] (n : ℕ),
ConvexOn 𝕜 (Set.Ici 0) fun x => x ^ n | true |
Lean.Parser.ParserState.stackSize | Lean.Parser.Types | Lean.Parser.ParserState → ℕ | true |
_private.Mathlib.Order.LiminfLimsup.0.Filter.HasBasis.liminf_eq_sSup_iUnion_iInter._simp_1_1 | Mathlib.Order.LiminfLimsup | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.IsCommComonObj | Mathlib.CategoryTheory.Monoidal.Comon_ | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.MonoidalCategory C] →
[CategoryTheory.BraidedCategory C] → (X : C) → [CategoryTheory.ComonObj X] → Prop | true |
_private.Mathlib.Data.Finsupp.MonomialOrder.0.MonomialOrder.lex_le_iff_of_unique._simp_1_1 | Mathlib.Data.Finsupp.MonomialOrder | ∀ {σ : Type u_1} [inst : LinearOrder σ] [inst_1 : WellFoundedGT σ] {c d : σ →₀ ℕ},
(MonomialOrder.lex.toSyn c ≤ MonomialOrder.lex.toSyn d) = (toLex c ≤ toLex d) | false |
_private.Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph.0.SimpleGraph.Walk.IsPath.neighborSet_toSubgraph_internal._proof_1_2 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {v u : V} {i : ℕ} {p : G.Walk u v}, i ≠ 0 → i < p.length → i - 1 < p.length | false |
measurableSet_insert._simp_1 | Mathlib.MeasureTheory.MeasurableSpace.Defs | ∀ {α : Type u_1} [inst : MeasurableSpace α] [MeasurableSingletonClass α] {a : α} {s : Set α},
MeasurableSet (insert a s) = MeasurableSet s | false |
IO.Promise._sizeOf_1 | Init.System.Promise | {α : Type} → [SizeOf α] → IO.Promise α → ℕ | false |
LT.lt.eq_bot | Mathlib.Order.Atoms | ∀ {α : Type u_2} [inst : Preorder α] [inst_1 : BoundedOrder α] [IsSimpleOrder α] {a b : α}, a < b → a = ⊥ | true |
CategoryTheory.Discrete.instSubsingleton | Mathlib.CategoryTheory.Discrete.Basic | ∀ {α : Type u₁} [Subsingleton α], Subsingleton (CategoryTheory.Discrete α) | true |
dist_right_pointReflection | Mathlib.Analysis.Normed.Affine.AddTorsor | ∀ {V : Type u_1} {P : Type u_2} [inst : SeminormedAddCommGroup V] [inst_1 : PseudoMetricSpace P]
[inst_2 : NormedAddTorsor V P] (𝕜 : Type u_5) [inst_3 : NormedField 𝕜] [NormedSpace 𝕜 V] (p q : P),
dist q ((Equiv.pointReflection p) q) = ‖2‖ * dist p q | true |
Std.DTreeMap.Internal.Impl.contains.eq_1 | Std.Data.DTreeMap.Internal.Queries | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] (k : α),
Std.DTreeMap.Internal.Impl.contains k Std.DTreeMap.Internal.Impl.leaf = false | true |
String.toList_copy_dropEnd | Init.Data.String.Lemmas.TakeDrop | ∀ {s : String} {n : ℕ}, (s.dropEnd n).copy.toList = List.take (s.length - n) s.toList | true |
_private.Batteries.Data.Char.Basic.0.Char.exists_eq_false_of_all_eq_false.match_1_6 | Batteries.Data.Char.Basic | ∀ {p : Char → Bool}
(motive :
((∃ x ∈ List.finRange Char.minSurrogate, ¬p (Char.ofNatAux ↑x ⋯) = true) ∨
∃ x ∈ List.finRange (Char.max - Char.maxSurrogate),
¬p (Char.ofNatAux (↑x + (Char.maxSurrogate + 1)) ⋯) = true) →
Prop)
(h :
(∃ x ∈ List.finRange Char.minSurrogate, ¬p (Char.ofNat... | false |
CategoryTheory.Monoidal.MonFunctorCategoryEquivalence.inverse._proof_6 | Mathlib.CategoryTheory.Monoidal.Internal.FunctorCategory | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} D] [inst_2 : CategoryTheory.MonoidalCategory D]
{X Y Z : CategoryTheory.Functor C (CategoryTheory.Mon D)} (f : X ⟶ Y) (g : Y ⟶ Z),
CategoryTheory.Mon.Hom.mk'
{ app := fun X_1 => ((Categ... | false |
SimpleGraph.Walk.mapToSubgraph._proof_4 | Mathlib.Combinatorics.SimpleGraph.Connectivity.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} {u : V} (v v_1 : V) (h : G.Adj u v_1) (p : G.Walk v_1 v),
↑⟨v_1, ⋯⟩ ∈ (SimpleGraph.Walk.cons h p).toSubgraph.verts | false |
Ideal.subset_pointwise_smul_iff | Mathlib.RingTheory.Ideal.Pointwise | ∀ {M : Type u_1} {R : Type u_2} [inst : Group M] [inst_1 : Semiring R] [inst_2 : MulSemiringAction M R] {a : M}
{S T : Ideal R}, S ≤ a • T ↔ a⁻¹ • S ≤ T | true |
QuadraticMap.IsometryEquiv.mk.injEq | Mathlib.LinearAlgebra.QuadraticForm.IsometryEquiv | ∀ {R : Type u_2} {M₁ : Type u_5} {M₂ : Type u_6} {N : Type u_9} [inst : CommSemiring R] [inst_1 : AddCommMonoid M₁]
[inst_2 : AddCommMonoid M₂] [inst_3 : AddCommMonoid N] [inst_4 : Module R M₁] [inst_5 : Module R M₂]
[inst_6 : Module R N] {Q₁ : QuadraticMap R M₁ N} {Q₂ : QuadraticMap R M₂ N} (toLinearEquiv : M₁ ≃ₗ[... | true |
inv_le_leOnePart | Mathlib.Algebra.Order.Group.PosPart | ∀ {α : Type u_1} [inst : Lattice α] [inst_1 : Group α] (a : α), a⁻¹ ≤ a⁻ᵐ | true |
Path.eqOn_extend_segment | Mathlib.Analysis.Convex.PathConnected | ∀ {E : Type u_1} [inst : AddCommGroup E] [inst_1 : Module ℝ E] [inst_2 : TopologicalSpace E] [inst_3 : ContinuousAdd E]
[inst_4 : ContinuousSMul ℝ E] (a b : E), Set.EqOn (⇑(Path.segment a b).extend) (⇑(AffineMap.lineMap a b)) unitInterval | true |
Lean.RBNode.all._unsafe_rec | Lean.Data.RBMap | {α : Type u} → {β : α → Type v} → ((k : α) → β k → Bool) → Lean.RBNode α β → Bool | false |
GromovHausdorff.candidatesBOfCandidates._proof_2 | Mathlib.Topology.MetricSpace.GromovHausdorffRealized | ∀ {X : Type u_1} {Y : Type u_2} [inst : MetricSpace X] [inst_1 : MetricSpace Y],
∀ f ∈ GromovHausdorff.candidates X Y, Continuous f | false |
Std.Http.Method.ofNat_ctorIdx | Std.Internal.Http.Data.Method | ∀ (x : Std.Http.Method), Std.Http.Method.ofNat x.ctorIdx = x | true |
BitVec.reduceRotateLeft._regBuiltin.BitVec.reduceRotateLeft.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec.1986106746._hygCtx._hyg.18 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | IO Unit | false |
FixedDetMatrices.reduce._proof_4 | Mathlib.LinearAlgebra.Matrix.FixedDetMatrices | NeZero (1 + 1) | false |
Set.Nontrivial.not_subset_singleton | Mathlib.Data.Set.Subsingleton | ∀ {α : Type u} {s : Set α} {x : α}, s.Nontrivial → ¬s ⊆ {x} | true |
_private.Mathlib.Algebra.Category.ModuleCat.Biproducts.0.lequivProdOfRightSplitExact'._proof_1 | Mathlib.Algebra.Category.ModuleCat.Biproducts | ∀ {R : Type u_1} [inst : Ring R], RingHomSurjective (RingHom.id R) | false |
Turing.PartrecToTM2.trLList.eq_1 | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.trLList [] = [] | true |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.withFields.go.match_5 | Lean.Elab.Structure | (motive : List Lean.MessageData → Sort u_1) →
(parentMsgs : List Lean.MessageData) →
((parent : Lean.MessageData) → motive [parent]) → ((x : List Lean.MessageData) → motive x) → motive parentMsgs | false |
Lean.Meta.Sym.ApplyResult.ctorIdx | Lean.Meta.Sym.Apply | Lean.Meta.Sym.ApplyResult → ℕ | false |
Aesop.BestFirstQueue.ActiveGoal.mk.noConfusion | Aesop.Search.Queue | {P : Sort u} →
{goal : Aesop.GoalRef} →
{priority : Aesop.Percent} →
{lastExpandedInIteration addedInIteration : Aesop.Iteration} →
{goal' : Aesop.GoalRef} →
{priority' : Aesop.Percent} →
{lastExpandedInIteration' addedInIteration' : Aesop.Iteration} →
{ goal := g... | false |
Lean.PrettyPrinter.Delaborator.delabLetE | Lean.PrettyPrinter.Delaborator.Builtins | Lean.PrettyPrinter.Delaborator.Delab | true |
_private.Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital.0._auto_149 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | Lean.Syntax | false |
IO.FS.Handle.truncate | Init.System.IO | IO.FS.Handle → IO Unit | true |
Algebra.SubmersivePresentation.instHasCoeffs | Mathlib.RingTheory.Extension.Presentation.Core | ∀ {R : Type u_1} {S : Type u_2} {ι : Type u_3} {σ : Type u_4} [inst : CommRing R] [inst_1 : CommRing S]
[inst_2 : Algebra R S] [inst_3 : Finite σ] (P : Algebra.SubmersivePresentation R S ι σ) (R₀ : Type u_5)
[inst_4 : CommRing R₀] [inst_5 : Algebra R₀ R] [inst_6 : Algebra R₀ S] [inst_7 : IsScalarTower R₀ R S]
[P.... | true |
CategoryTheory.MonoidalCategory.tensorμ_natural_left | Mathlib.CategoryTheory.Monoidal.Braided.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C]
[inst_2 : CategoryTheory.BraidedCategory C] {X₁ X₂ Y₁ Y₂ : C} (f₁ : X₁ ⟶ Y₁) (f₂ : X₂ ⟶ Y₂) (Z₁ Z₂ : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerRight (CategoryTheo... | true |
Thunk.mk._flat_ctor | Init.Core | {α : Type u} → (Unit → α) → Thunk α | false |
Std.Time.Millisecond.instLEOffset | Std.Time.Time.Unit.Millisecond | LE Std.Time.Millisecond.Offset | true |
CategoryTheory.MonoidalCategory.MonoidalRightAction.rightActionOfMonoidalOppositeLeftAction._proof_11 | Mathlib.CategoryTheory.Monoidal.Action.Opposites | ∀ (C : Type u_4) (D : Type u_2) [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.MonoidalCategory C] [inst_2 : CategoryTheory.Category.{u_1, u_2} D]
[inst_3 : CategoryTheory.MonoidalCategory.MonoidalLeftAction Cᴹᵒᵖ D] (c₁ c₂ c₃ : C) (d : D),
CategoryTheory.CategoryStruct.comp
(Category... | false |
_private.Init.Data.String.Search.0.String.findAux._proof_1 | Init.Data.String.Search | ∀ (s : String) (stopPos pos : String.Pos.Raw),
pos ≤ stopPos ∧ String.Pos.Raw.IsValid s pos ∧ String.Pos.Raw.IsValid s stopPos → String.Pos.Raw.IsValid s pos | false |
DeltaGenerated.toTop | Mathlib.Topology.Category.DeltaGenerated | DeltaGenerated → TopCat | true |
MulAction.instDecidablePredMemSetFixedByOfDecidableEq._proof_1 | Mathlib.GroupTheory.GroupAction.Basic | ∀ {M : Type u_2} [inst : Monoid M] {β : Type u_1} [inst_1 : MulAction M β] (m : M) (b : β),
Decidable (b ∈ MulAction.fixedBy β m) = Decidable (m • b = b) | false |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.expansion_empty | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] (K : ℝ) (S : Finset G), Finset.expansion✝ K S ∅ = 0 | true |
_private.Lean.Meta.Tactic.Apply.0.Lean.MVarId.apply.go._unsafe_rec | Lean.Meta.Tactic.Apply | Lean.MVarId →
Lean.Meta.ApplyConfig →
Option Lean.MessageData →
Lean.Expr → Lean.Expr → Std.Rco ℕ → ℕ → Lean.MetaM (Array Lean.Expr × Array Lean.BinderInfo) | false |
MulEquiv.recOn | Mathlib.Algebra.Group.Equiv.Defs | {M : Type u_9} →
{N : Type u_10} →
[inst : Mul M] →
[inst_1 : Mul N] →
{motive : M ≃* N → Sort u} →
(t : M ≃* N) →
((toEquiv : M ≃ N) →
(map_mul' : ∀ (x y : M), toEquiv.toFun (x * y) = toEquiv.toFun x * toEquiv.toFun y) →
motive { toEquiv := to... | false |
_private.Mathlib.Geometry.Manifold.MFDeriv.Basic.0.mdifferentiableOn_iff_of_mem_maximalAtlas._simp_1_1 | Mathlib.Geometry.Manifold.MFDeriv.Basic | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {p : β → Prop}, (∀ y ∈ f '' s, p y) = ∀ ⦃x : α⦄, x ∈ s → p (f x) | false |
instSliceableByteArrayNatByteSlice_6 | Std.Data.ByteSlice | Std.Ric.Sliceable ByteArray ℕ ByteSlice | true |
Set.Ioc.instPow._proof_1 | Mathlib.Algebra.Order.Interval.Set.Instances | ∀ {R : Type u_1} [inst : Semiring R] [inst_1 : PartialOrder R] [IsStrictOrderedRing R] (p : ↑(Set.Ioc 0 1)) (n : ℕ),
0 < ↑p ^ n ∧ ↑p ^ n ≤ 1 | false |
CategoryTheory.Localization.Monoidal.functorMonoidalOfComp_μ | Mathlib.CategoryTheory.Localization.Monoidal.Functor | ∀ {C : Type u_1} {D : Type u_2} {E : Type u_3} [inst : CategoryTheory.Category.{v_1, u_1} C]
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] [inst_2 : CategoryTheory.Category.{v_3, u_3} E]
[inst_3 : CategoryTheory.MonoidalCategory C] [inst_4 : CategoryTheory.MonoidalCategory D]
[inst_5 : CategoryTheory.MonoidalCa... | true |
BitVec.DivModState.udiv_eq_of_lawful | Init.Data.BitVec.Bitblast | ∀ {w : ℕ} {n d : BitVec w} {qr : BitVec.DivModState w},
BitVec.DivModState.Lawful { n := n, d := d } qr → qr.wn = 0 → n / d = qr.q | true |
Int.sub_one_lt_floor | Mathlib.Algebra.Order.Floor.Ring | ∀ {R : Type u_2} [inst : Ring R] [inst_1 : LinearOrder R] [inst_2 : FloorRing R] [IsOrderedRing R] (a : R), a - 1 < ↑⌊a⌋ | true |
Aesop.BuiltinRules.splitHypothesesCore._unsafe_rec | Aesop.BuiltinRules.Split | Lean.MVarId → Aesop.ScriptM (Option (Array Lean.MVarId)) | false |
IsCyclotomicExtension.iff_union_singleton_one | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (S : Set ℕ) (A : Type u) (B : Type v) [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B],
IsCyclotomicExtension S A B ↔ IsCyclotomicExtension (S ∪ {1}) A B | true |
CategoryTheory.FunctorToTypes.inr_comp_binaryCoproductIso_hom_apply | Mathlib.CategoryTheory.Limits.Shapes.FunctorToTypes | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (F G : CategoryTheory.Functor C (Type w)) (a : C)
(x : G.obj a),
(CategoryTheory.FunctorToTypes.binaryCoproductIso F G).hom.app a (CategoryTheory.Limits.coprod.inr.app a x) =
Sum.inr x | true |
_private.Mathlib.Topology.Sober.0.quasiSober_of_open_cover._simp_1_1 | Mathlib.Topology.Sober | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p q : A}, (p = q) = (↑p = ↑q) | false |
_private.Mathlib.Tactic.FieldSimp.0.Mathlib.Tactic.FieldSimp.normalize.match_15 | Mathlib.Tactic.FieldSimp | {v : Lean.Level} →
{M : Q(Type v)} →
(iM : Q(CommGroupWithZero «$M»)) →
(s : ℕ) →
(y' : Q(«$M»)) →
(g : Mathlib.Tactic.FieldSimp.Sign M) →
(motive :
((G : Mathlib.Tactic.FieldSimp.Sign M) ×
have a := G.expr q(«$y'» ^ «$s»);
... | false |
_private.Init.Data.Vector.Extract.0.Vector.extract_succ_right._proof_1 | Init.Data.Vector.Extract | ∀ {n i j : ℕ}, i < j + 1 → j < n → ¬min j n - i + 1 = min (j + 1) n - i → False | false |
_private.Mathlib.GroupTheory.GroupAction.Blocks.0.MulAction.isBlock_subgroup'._simp_1_1 | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {α : Type u} {s t : Set α}, Disjoint s t = ∀ ⦃a : α⦄, a ∈ s → a ∉ t | false |
CategoryTheory.Functor.OneHypercoverDenseData.essSurj.presheafObjObjIso.eq_1 | Mathlib.CategoryTheory.Sites.DenseSubsite.OneHypercoverDense | ∀ {C₀ : Type u₀} {C : Type u} [inst : CategoryTheory.Category.{v₀, u₀} C₀] [inst_1 : CategoryTheory.Category.{v, u} C]
{F : CategoryTheory.Functor C₀ C} {J₀ : CategoryTheory.GrothendieckTopology C₀}
{J : CategoryTheory.GrothendieckTopology C} {A : Type u'} [inst_2 : CategoryTheory.Category.{v', u'} A]
[inst_3 : C... | true |
_private.Init.Data.BitVec.Lemmas.0.BitVec.toInt_ofInt_eq_self._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {n : ℤ}, n < 2 ^ (w - 1) → ¬n < (2 ^ (w - 1 + 1) + 1) / 2 → False | false |
CategoryTheory.Functor.CoconeTypes | Mathlib.CategoryTheory.Limits.Types.ColimitType | {J : Type u} →
[inst : CategoryTheory.Category.{v, u} J] → CategoryTheory.Functor J (Type w₀) → Type (max (max u w₀) (w₁ + 1)) | true |
CategoryTheory.Functor.CommShift₂.mk.noConfusion | Mathlib.CategoryTheory.Shift.CommShiftTwo | {C₁ : Type u_1} →
{C₂ : Type u_3} →
{D : Type u_5} →
{inst : CategoryTheory.Category.{v_1, u_1} C₁} →
{inst_1 : CategoryTheory.Category.{v_3, u_3} C₂} →
{inst_2 : CategoryTheory.Category.{v_5, u_5} D} →
{M : Type u_6} →
{inst_3 : AddCommMonoid M} →
... | false |
Equiv.dvd | Mathlib.Algebra.Ring.Divisibility.Basic | {G : Type u_4} → [inst : LeftCancelSemigroup G] → (g : G) → G ≃ { a // g ∣ a } | true |
FirstOrder.Language.BoundedFormula.listDecode.eq_1 | Mathlib.ModelTheory.Encoding | ∀ {L : FirstOrder.Language} {α : Type u'} (n : ℕ)
(l : List ((k : ℕ) × L.Term (α ⊕ Fin k) ⊕ (n : ℕ) × L.Relations n ⊕ ℕ)),
FirstOrder.Language.BoundedFormula.listDecode (Sum.inr (Sum.inr n.succ.succ) :: l) =
⟨n, FirstOrder.Language.BoundedFormula.falsum⟩ :: FirstOrder.Language.BoundedFormula.listDecode l | true |
CompleteOrthogonalIdempotents.iff_ortho_complete | Mathlib.RingTheory.Idempotents | ∀ {R : Type u_1} [inst : Semiring R] {I : Type u_3} {e : I → R} [inst_1 : Fintype I],
CompleteOrthogonalIdempotents e ↔ (Pairwise fun x1 x2 => e x1 * e x2 = 0) ∧ ∑ i, e i = 1 | true |
Lean.Meta.Grind.propagateBoolOrUp | Lean.Meta.Tactic.Grind.Propagate | Lean.Meta.Grind.Propagator | true |
Lean.Elab.Do.CodeLiveness.ctorElim | Lean.Elab.Do.Basic | {motive : Lean.Elab.Do.CodeLiveness → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Elab.Do.CodeLiveness) → ctorIdx = t.ctorIdx → Lean.Elab.Do.CodeLiveness.ctorElimType ctorIdx → motive t | false |
CategoryTheory.FreeBicategory.Hom₂.whisker_left | Mathlib.CategoryTheory.Bicategory.Free | {B : Type u} →
[inst : Quiver B] →
{a b c : CategoryTheory.FreeBicategory B} →
(f : a ⟶ b) →
{g h : b ⟶ c} →
CategoryTheory.FreeBicategory.Hom₂ g h →
CategoryTheory.FreeBicategory.Hom₂ (CategoryTheory.CategoryStruct.comp f g)
(CategoryTheory.CategoryStruct.comp f ... | true |
Lean.Elab.Tactic.Doc.TacticDoc.noConfusion | Lean.Elab.Tactic.Doc | {P : Sort u} → {t t' : Lean.Elab.Tactic.Doc.TacticDoc} → t = t' → Lean.Elab.Tactic.Doc.TacticDoc.noConfusionType P t t' | false |
CategoryTheory.PreZeroHypercover.toShrink | Mathlib.CategoryTheory.Sites.Hypercover.Zero | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] → {S : C} → (E : CategoryTheory.PreZeroHypercover S) → E.Hom E.shrink | true |
Lean.Lsp.instInhabitedDiagnosticCode | Lean.Data.Lsp.Diagnostics | Inhabited Lean.Lsp.DiagnosticCode | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.