name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
singleton_mul_mem_nhds_of_nhds_one | Mathlib.Topology.Algebra.Group.Pointwise | ∀ {α : Type u} [inst : TopologicalSpace α] [inst_1 : Group α] [ContinuousConstSMul α α] {s : Set α} (a : α),
s ∈ nhds 1 → {a} * s ∈ nhds a | true |
HomotopicalAlgebra.PathObject.instIsFibrantP | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {A : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] (P : HomotopicalAlgebra.PathObject A)
[inst_2 : CategoryTheory.Limits.HasBinaryProduct A A] [inst_3 : HomotopicalAlgebra.CategoryWithFibrations C]
[inst_4 : CategoryTheory.Limits.HasTermin... | true |
_private.Lean.Environment.0.Lean.ImportedModule.needsData | Lean.Environment | Lean.ImportedModule✝ → Bool | true |
USize.add_zero | Init.Data.UInt.Lemmas | ∀ (a : USize), a + 0 = a | true |
_private.Mathlib.RingTheory.Regular.RegularSequence.0.RingTheory.Sequence.IsWeaklyRegular.prototype_perm.aux | Mathlib.RingTheory.Regular.RegularSequence | ∀ {R : Type u_1} {M : Type u_3} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] {rs : List R},
(∀ (a b : R) (rs' : List R),
(a :: b :: rs').Subperm rs →
have K := Submodule.torsionBy R (M ⧸ Ideal.ofList rs' • ⊤) b;
K = a • K → K = ⊥) →
∀ {rs₁ rs₂ : List R} (rs₀ : List R),... | true |
Int32.ofIntTruncate_int16ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int16), Int32.ofIntTruncate x.toInt = x.toInt32 | true |
CategoryTheory.MorphismProperty.CostructuredArrow.toOver._proof_1 | Mathlib.CategoryTheory.MorphismProperty.Comma | ∀ {C : Type u_4} {D : Type u_1} [inst : CategoryTheory.Category.{u_3, u_4} C]
[inst_1 : CategoryTheory.Category.{u_2, u_1} D] (P : CategoryTheory.MorphismProperty D)
(F : CategoryTheory.Functor C D) (X : D) {X_1 Y : P.CostructuredArrow ⊤ F X} (f : X_1 ⟶ Y), ⊤ (F.map f.left) | false |
MeasureTheory.IsFundamentalDomain.sum_restrict | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ → (MeasureTheory.Measure.sum fun g => μ.restric... | true |
CategoryTheory.Functor.mapCoconeMapCocone | Mathlib.CategoryTheory.Limits.Cones | {J : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} J] →
{C : Type u₃} →
[inst_1 : CategoryTheory.Category.{v₃, u₃} C] →
{D : Type u₄} →
[inst_2 : CategoryTheory.Category.{v₄, u₄} D] →
{E : Type u₅} →
[inst_3 : CategoryTheory.Category.{v₅, u₅} E] →
... | true |
CategoryTheory.ObjectProperty.IsClosedUnderKernels.casesOn | Mathlib.CategoryTheory.ObjectProperty.Kernels | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{P : CategoryTheory.ObjectProperty C} →
{motive : P.IsClosedUnderKernels → Sort u} →
(t : P.IsClosedUnderKernels) →
((kernels_le : (CategoryTheory.MorphismProp... | false |
_private.Mathlib.Analysis.Real.Pi.Bounds.0.Real.«_aux_Mathlib_Analysis_Real_Pi_Bounds___elabRules_Real_tacticPi_lower_bound[_,,]_1».unsafe_impl_3 | Mathlib.Analysis.Real.Pi.Bounds | Lean.Expr → Lean.MetaM ℚ | false |
Matrix.zpow_add | Mathlib.LinearAlgebra.Matrix.ZPow | ∀ {n' : Type u_1} [inst : DecidableEq n'] [inst_1 : Fintype n'] {R : Type u_2} [inst_2 : CommRing R]
{A : Matrix n' n' R}, IsUnit A.det → ∀ (m n : ℤ), A ^ (m + n) = A ^ m * A ^ n | true |
ModuleCon.instSMulQuotient._aux_1 | Mathlib.Algebra.Module.Congruence.Defs | {S : Type u_1} →
(M : Type u_2) →
[inst : SMul S M] → [inst_1 : Add M] → (c : ModuleCon S M) → S → ModuleCon.Quotient M c → ModuleCon.Quotient M c | false |
String.Legacy.Iterator.find._unary | Init.Data.String.Iterator | (Char → Bool) → String.Legacy.Iterator → String.Legacy.Iterator | false |
Finset.set_biInter_inter | Mathlib.Order.CompleteLattice.Finset | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq α] (s t : Finset α) (u : α → Set β),
⋂ x ∈ s ∪ t, u x = (⋂ x ∈ s, u x) ∩ ⋂ x ∈ t, u x | true |
_private.Lean.Compiler.LCNF.LambdaLifting.0.Lean.Compiler.LCNF.LambdaLifting.etaContractibleDecl?._sparseCasesOn_10 | Lean.Compiler.LCNF.LambdaLifting | {pu : Lean.Compiler.LCNF.Purity} →
{motive_4 : Lean.Compiler.LCNF.Code pu → Sort u} →
(t : Lean.Compiler.LCNF.Code pu) →
((fvarId : Lean.FVarId) → motive_4 (Lean.Compiler.LCNF.Code.return fvarId)) →
(Nat.hasNotBit 32 t.ctorIdx → motive_4 t) → motive_4 t | false |
Topology.IsInducing.isClosed_iff | Mathlib.Topology.Maps.Basic | ∀ {X : Type u_1} {Y : Type u_2} {f : X → Y} [inst : TopologicalSpace Y] [inst_1 : TopologicalSpace X],
Topology.IsInducing f → ∀ {s : Set X}, IsClosed s ↔ ∃ t, IsClosed t ∧ f ⁻¹' t = s | true |
CategoryTheory.AddMon.mk.noConfusion | Mathlib.CategoryTheory.Monoidal.Mon_ | {C : Type u₁} →
{inst : CategoryTheory.Category.{v₁, u₁} C} →
{inst_1 : CategoryTheory.MonoidalCategory C} →
{P : Sort u} →
{X : C} →
{addMon : CategoryTheory.AddMonObj X} →
{X' : C} →
{addMon' : CategoryTheory.AddMonObj X'} →
{ X := X, addMon := a... | false |
Lean.Meta.instReduceEvalBinderInfo_qq._sparseCasesOn_3 | Qq.ForLean.ReduceEval | {motive : Lean.Name → Sort u} →
(t : Lean.Name) → motive Lean.Name.anonymous → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Limits.IsLimit.op._proof_2 | Mathlib.CategoryTheory.Limits.HasLimits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] {C : Type u_4}
[inst_1 : CategoryTheory.Category.{u_2, u_4} C] {F : CategoryTheory.Functor J C} {t : CategoryTheory.Limits.Cone F}
(P : CategoryTheory.Limits.IsLimit t) (s : CategoryTheory.Limits.Cocone F.op) (j : Jᵒᵖ),
(CategoryTheory.CategoryStruct.... | false |
Std.DTreeMap.Internal.Impl.balanceRErase.eq_6 | Std.Data.DTreeMap.Internal.Balancing | ∀ {α : Type u} {β : α → Type v} (k : α) (v : β k) (rs : ℕ) (k_1 : α) (v_1 : β k_1)
(l_1 r_2 : Std.DTreeMap.Internal.Impl α β) (hrb_2 : (Std.DTreeMap.Internal.Impl.inner rs k_1 v_1 l_1 r_2).Balanced)
(hlb_1 : Std.DTreeMap.Internal.Impl.leaf.Balanced)
(hlr_3 :
Std.DTreeMap.Internal.Impl.BalanceLErasePrecond Std... | true |
MeasureTheory.Measure.InnerRegularCompactLTTop.casesOn | Mathlib.MeasureTheory.Measure.Regular | {α : Type u_1} →
[inst : MeasurableSpace α] →
[inst_1 : TopologicalSpace α] →
{μ : MeasureTheory.Measure α} →
{motive : μ.InnerRegularCompactLTTop → Sort u} →
(t : μ.InnerRegularCompactLTTop) →
((innerRegular : μ.InnerRegularWRT IsCompact fun s => MeasurableSet s ∧ μ s ≠ ⊤) → m... | false |
_private.Init.Data.List.TakeDrop.0.List.filter.match_1.eq_2 | Init.Data.List.TakeDrop | ∀ (motive : Bool → Sort u_1) (h_1 : Unit → motive true) (h_2 : Unit → motive false),
(match false with
| true => h_1 ()
| false => h_2 ()) =
h_2 () | true |
Algebra.QuasiFinite.rec | Mathlib.RingTheory.QuasiFinite.Basic | {R : Type u_1} →
{S : Type u_2} →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
{motive : Algebra.QuasiFinite R S → Sort u} →
((finite_fiber : ∀ (P : Ideal R) [inst_3 : P.IsPrime], Module.Finite P.ResidueField (P.Fiber S)) →
motive ⋯) →
... | false |
List.choose_property | Mathlib.Data.List.Basic | ∀ {α : Type u} (p : α → Prop) [inst : DecidablePred p] (l : List α) (hp : ∃ a ∈ l, p a), p (List.choose p l hp) | true |
Int.mul_eq_one_iff_eq_one_or_neg_one | Mathlib.Algebra.Group.Int.Units | ∀ {u v : ℤ}, u * v = 1 ↔ u = 1 ∧ v = 1 ∨ u = -1 ∧ v = -1 | true |
Lean.Elab.Term.elabCoe | Lean.Elab.BuiltinNotation | Lean.Elab.Term.TermElab | true |
CategoryTheory.PreOneHypercover.isoMk_aux._proof_2 | Mathlib.CategoryTheory.Sites.Hypercover.One | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {S : C} {E : CategoryTheory.PreOneHypercover S}
{F : CategoryTheory.PreOneHypercover S} (s₀ : E.I₀ ≃ F.I₀) (s₁ : ⦃i j : E.I₀⦄ → E.I₁ i j ≃ F.I₁ (s₀ i) (s₀ j))
{i j : E.I₀} (k : E.I₁ i j),
E.Y ((CategoryTheory.PreOneHypercover.congrIndexOneOfEq ⋯ ⋯) k)... | false |
_private.Lean.Elab.Tactic.Conv.Congr.0.Lean.Elab.Tactic.Conv.extCore.match_9 | Lean.Elab.Tactic.Conv.Congr | (motive : Option Lean.MVarId → Sort u_1) →
(__do_lift : Option Lean.MVarId) →
((mvarId : Lean.MVarId) → motive (some mvarId)) → ((x : Option Lean.MVarId) → motive x) → motive __do_lift | false |
_private.Init.Data.List.ToArray.0.List.findFinIdx?_loop_toArray._proof_1_2 | Init.Data.List.ToArray | ∀ {α : Type u_1} {j : ℕ} {l : List α} {h : [].length + j = l.length}, j = l.length → j < l.length → False | false |
Function.Injective.addAction._proof_2 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_2} {α : Type u_3} {β : Type u_1} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : β → α),
Function.Injective f →
(∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x) → ∀ (c₁ c₂ : M) (x : β), (c₁ + c₂) +ᵥ x = c₁ +ᵥ c₂ +ᵥ x | false |
List.max_toArray | Init.Data.Array.MinMax | ∀ {α : Type u_1} [inst : Max α] {l : List α} {h : l.toArray ≠ #[]}, l.toArray.max h = l.max ⋯ | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0._regBuiltin.Char.reduceToNat.declare_28._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.3228376024._hygCtx._hyg.13 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | false |
Lean.Elab.Term.Do.Alt.ref | Lean.Elab.Do.Legacy | {σ : Type} → Lean.Elab.Term.Do.Alt σ → Lean.Syntax | true |
_private.Mathlib.Analysis.Convex.Join.0.convexJoin_iUnion_left._simp_1_2 | Mathlib.Analysis.Convex.Join | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i | false |
CategoryTheory.Functor.inlCompSum' | Mathlib.CategoryTheory.Sums.Basic | {A : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} A] →
{B : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} B] →
{C : Type u₃} →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C] →
(F : CategoryTheory.Functor A C) →
(G : CategoryTheory.Functor B C) → (Cat... | true |
Filter.mem_principal._simp_1 | Mathlib.Order.Filter.Defs | ∀ {α : Type u_1} {s t : Set α}, (s ∈ Filter.principal t) = (t ⊆ s) | false |
GenContFract.IntFractPair.nth_stream_fr_nonneg_lt_one | Mathlib.Algebra.ContinuedFractions.Computation.Approximations | ∀ {K : Type u_1} {v : K} {n : ℕ} [inst : Field K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K]
[inst_3 : FloorRing K] {ifp_n : GenContFract.IntFractPair K},
GenContFract.IntFractPair.stream v n = some ifp_n → 0 ≤ ifp_n.fr ∧ ifp_n.fr < 1 | true |
_private.Mathlib.LinearAlgebra.Eigenspace.Pi.0.Module.End.iInf_maxGenEigenspace_restrict_map_subtype_eq._simp_1_2 | Mathlib.LinearAlgebra.Eigenspace.Pi | ∀ {α : Type u_1} [inst : Preorder α] (a : α), (a ≤ a) = True | false |
IO.Process.exit | Init.System.IO | {α : Type} → UInt8 → IO α | true |
Std.TreeSet.size_le_size_insert | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] {k : α}, t.size ≤ (t.insert k).size | true |
_private.Mathlib.Combinatorics.SimpleGraph.Subgraph.0.SimpleGraph.Subgraph.spanningCoe_coe._proof_1_5 | Mathlib.Combinatorics.SimpleGraph.Subgraph | ∀ {V : Type u_1} {G : SimpleGraph V} (G' : G.Subgraph) (x x_1 : V), G'.spanningCoe.Adj x x_1 → x_1 ∈ G'.verts | false |
Lean.LibrarySuggestions.Config.filter | Lean.LibrarySuggestions.Basic | Lean.LibrarySuggestions.Config → Lean.Name → Lean.MetaM Bool | true |
CategoryTheory.Functor.ranCompLimIso._proof_1 | Mathlib.CategoryTheory.Functor.KanExtension.Adjunction | ∀ {C : Type u_3} {D : Type u_5} [inst : CategoryTheory.Category.{u_4, u_3} C]
[inst_1 : CategoryTheory.Category.{u_6, u_5} D] {H : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} H]
(L : CategoryTheory.Functor C D) [inst_3 : ∀ (G : CategoryTheory.Functor C H), L.HasRightKanExtension G]
[inst_4 : CategoryTh... | false |
ShareCommon.StateFactoryImpl.mapFind? | Init.ShareCommon | (self : ShareCommon.StateFactoryImpl) → self.Map → ShareCommon.Object → Option ShareCommon.Object | true |
SimpleGraph.cliqueFinset | Mathlib.Combinatorics.SimpleGraph.Clique | {α : Type u_1} → (G : SimpleGraph α) → [Fintype α] → [DecidableEq α] → [DecidableRel G.Adj] → ℕ → Finset (Finset α) | true |
equivShrink_top | Mathlib.Order.Shrink | ∀ {α : Type u_1} [inst : Small.{u, u_1} α] [inst_1 : Top α], (equivShrink α) ⊤ = ⊤ | true |
Std.Time.Year.noConfusion | Std.Time.Format.Basic | {P : Sort u} → {t t' : Std.Time.Year} → t = t' → Std.Time.Year.noConfusionType P t t' | false |
StarSubalgebra.map_topologicalClosure_le | Mathlib.Topology.Algebra.StarSubalgebra | ∀ {R : Type u_1} {A : Type u_2} {B : Type u_3} [inst : CommSemiring R] [inst_1 : StarRing R]
[inst_2 : TopologicalSpace A] [inst_3 : Semiring A] [inst_4 : Algebra R A] [inst_5 : StarRing A]
[inst_6 : StarModule R A] [inst_7 : IsSemitopologicalSemiring A] [inst_8 : ContinuousStar A]
[inst_9 : TopologicalSpace B] [... | true |
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.IsAtom.eq_of_inter_nonempty | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {G : Type u_1} [inst : Group G] [inst_1 : DecidableEq G] {K : ℝ} {A B S : Finset G},
K ≤ 1 → S.Nonempty → Finset.IsAtom✝ K S A → Finset.IsAtom✝¹ K S B → (A ∩ B).Nonempty → A = B | true |
Std.DTreeMap.Raw.getKey?_erase_self | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp],
t.WF → ∀ {k : α}, (t.erase k).getKey? k = none | true |
Cardinal.beth_add_one | Mathlib.SetTheory.Cardinal.Aleph | ∀ (o : Ordinal.{u_1}), Cardinal.beth (o + 1) = 2 ^ Cardinal.beth o | true |
CategoryTheory.Monad.MonadicityInternal.comparisonAdjunction | Mathlib.CategoryTheory.Monad.Monadicity | {C : Type u₁} →
{D : Type u₂} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
[inst_1 : CategoryTheory.Category.{v₁, u₂} D] →
{G : CategoryTheory.Functor D C} →
{F : CategoryTheory.Functor C D} →
(adj : F ⊣ G) →
[inst_2 :
∀ (A : adj.toMonad.Algeb... | true |
ZeroAtInftyContinuousMap.instAddGroup._proof_1 | Mathlib.Topology.ContinuousMap.ZeroAtInfty | ∀ {α : Type u_1} {β : Type u_2} [inst : TopologicalSpace α] [inst_1 : TopologicalSpace β] [inst_2 : AddGroup β],
Function.Injective fun f => ⇑f | false |
SimplexCategoryGenRel.instIsSplitMonoδ | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.EpiMono | ∀ {n : ℕ} {i : Fin (n + 2)}, CategoryTheory.IsSplitMono (SimplexCategoryGenRel.δ i) | true |
ByteArray.extract_append_eq_left | Init.Data.ByteArray.Lemmas | ∀ {a b : ByteArray} {i : ℕ}, i = a.size → (a ++ b).extract 0 i = a | true |
antitone_lt | Mathlib.Order.BoundedOrder.Monotone | ∀ {α : Type u} [inst : Preorder α] {x : α}, Antitone fun x_1 => x_1 < x | true |
Lean.Level.ofNat.match_1 | Lean.Level | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
IsKleinFour.eq_finset_univ | Mathlib.GroupTheory.SpecificGroups.KleinFour | ∀ {G : Type u_1} [inst : Group G] [IsKleinFour G] [inst_2 : Fintype G] [inst_3 : DecidableEq G] {x y : G},
x ≠ 1 → y ≠ 1 → x ≠ y → {x * y, x, y, 1} = Finset.univ | true |
CategoryTheory.SingleFunctors.Hom.mk._flat_ctor | Mathlib.CategoryTheory.Shift.SingleFunctors | {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] →
{A : Type u_5} →
[inst_2 : AddMonoid A] →
[inst_3 : CategoryTheory.HasShift D A] →
{F G : CategoryTheory.SingleFunctors C D A} →
... | false |
AddValuation.map_pow | Mathlib.RingTheory.Valuation.Basic | ∀ {R : Type u_3} {Γ₀ : Type u_4} [inst : Ring R] [inst_1 : LinearOrderedAddCommMonoidWithTop Γ₀] (v : AddValuation R Γ₀)
(x : R) (n : ℕ), v (x ^ n) = n • v x | true |
_private.Lean.Meta.Tactic.Grind.PropagateInj.0.Lean.Meta.Grind.getInvFor?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.PropagateInj | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.Limits.IsIndObject.casesOn | Mathlib.CategoryTheory.Limits.Indization.IndObject | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{A : CategoryTheory.Functor Cᵒᵖ (Type v)} →
{motive : CategoryTheory.Limits.IsIndObject A → Sort u_1} →
(t : CategoryTheory.Limits.IsIndObject A) →
((nonempty_presentation : Nonempty (CategoryTheory.Limits.IndObjectPresentation A))... | false |
nhdsWithin_inter | Mathlib.Topology.NhdsWithin | ∀ {α : Type u_1} [inst : TopologicalSpace α] (a : α) (s t : Set α),
nhdsWithin a (s ∩ t) = nhdsWithin a s ⊓ nhdsWithin a t | true |
Lean.Elab.Command.State.auxDeclNGen | Lean.Elab.Command | Lean.Elab.Command.State → Lean.DeclNameGenerator | true |
_private.Init.Grind.ToInt.0.Lean.Grind.instBEqIntInterval.beq_spec_3 | Init.Grind.ToInt | ∀ (a b : ℤ), (Lean.Grind.IntInterval.io a == Lean.Grind.IntInterval.io b) = (a == b) | true |
_private.Lean.Meta.Tactic.Grind.Arith.Cutsat.CommRing.0.Int.Linear.Poly.normCommRing?._sparseCasesOn_1 | Lean.Meta.Tactic.Grind.Arith.Cutsat.CommRing | {α : Type u} →
{motive : Option α → Sort u_1} →
(t : Option α) → ((val : α) → motive (some val)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
FreeAddGroup.red_negRev_iff | Mathlib.GroupTheory.FreeGroup.Basic | ∀ {α : Type u} {L₁ L₂ : List (α × Bool)},
FreeAddGroup.Red (FreeAddGroup.negRev L₁) (FreeAddGroup.negRev L₂) ↔ FreeAddGroup.Red L₁ L₂ | true |
CategoryTheory.Comonad.Coalgebra.isoMk.congr_simp | Mathlib.CategoryTheory.Monad.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {G : CategoryTheory.Comonad C} {A B : G.Coalgebra}
(h h_1 : A.A ≅ B.A) (e_h : h = h_1)
(w : CategoryTheory.CategoryStruct.comp A.a (G.map h.hom) = CategoryTheory.CategoryStruct.comp h.hom B.a),
CategoryTheory.Comonad.Coalgebra.isoMk h w = CategoryTheory.... | true |
_private.Lean.Elab.Tactic.Do.Syntax.0.Std.Do.elabTriple.match_1 | Lean.Elab.Tactic.Do.Syntax | (motive : Option Lean.Level → Sort u_1) →
(__discr : Option Lean.Level) →
((v : Lean.Level) → motive (some v)) → ((x : Option Lean.Level) → motive x) → motive __discr | false |
Finsupp.instAddGroup._proof_3 | Mathlib.Algebra.Group.Finsupp | ∀ {ι : Type u_1} {G : Type u_2} [inst : AddGroup G],
autoParam (∀ (n : ℕ) (a : ι →₀ G), ↑n.succ • a = ↑n • a + a) SubNegMonoid.zsmul_succ'._autoParam | false |
Multiset.disjoint_singleton | Mathlib.Data.Multiset.UnionInter | ∀ {α : Type u_1} {l : Multiset α} {a : α}, Disjoint l {a} ↔ a ∉ l | true |
instCommutativeISizeHAnd | Init.Data.SInt.Bitwise | Std.Commutative fun x1 x2 => x1 &&& x2 | true |
CategoryTheory.LeftExactFunctor.whiskeringLeft._proof_7 | Mathlib.CategoryTheory.Limits.ExactFunctor | ∀ (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] (E : Type u_5) [inst_2 : CategoryTheory.Category.{u_6, u_5} E]
{X Y Z : C ⥤ₗ D} (f : X ⟶ Y) (g : Y ⟶ Z),
{
app := fun H =>
CategoryTheory.ObjectProperty.homMk
(((Ca... | false |
Nat.ascFactorialBinary.match_1.congr_eq_2 | Mathlib.Data.Nat.Factorial.Basic | ∀ (motive : ℕ → Sort u_1) (k : ℕ) (h_1 : Unit → motive 0) (h_2 : Unit → motive 1)
(h_3 : (k n : ℕ) → k = n + 2 → motive n.succ.succ),
k = 1 →
(match k with
| 0 => h_1 ()
| 1 => h_2 ()
| k@h:n.succ.succ => h_3 k n h) ≍
h_2 () | true |
CommMonoid.ctorIdx | Mathlib.Algebra.Group.Defs | {M : Type u} → CommMonoid M → ℕ | false |
tprod_eq_one_of_not_multipliable | Mathlib.Topology.Algebra.InfiniteSum.Defs | ∀ {α : Type u_1} {β : Type u_2} [inst : CommMonoid α] [inst_1 : TopologicalSpace α] {L : SummationFilter β} {f : β → α},
¬Multipliable f L → ∏'[L] (b : β), f b = 1 | true |
_private.LeanSearchClient.Syntax.0.LeanSearchClient.stateSearchCache._proof_1 | LeanSearchClient.Syntax | Nonempty (ST.Ref IO.RealWorld (Std.HashMap (String × ℕ × String) (Array Lean.Json))) | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.getKey!_filter_key._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
PFunctor.Approx.CofixA.intro.noConfusion | Mathlib.Data.PFunctor.Univariate.M | {F : PFunctor.{uA, uB}} →
{P : Sort u} →
{n : ℕ} →
{a : F.A} →
{a_1 : F.B a → PFunctor.Approx.CofixA F n} →
{n' : ℕ} →
{a' : F.A} →
{a'_1 : F.B a' → PFunctor.Approx.CofixA F n'} →
n.succ = n'.succ →
PFunctor.Approx.CofixA.intro a ... | false |
Mathlib.Tactic.Abel.evalSMul | Mathlib.Tactic.Abel | Lean.Expr × ℤ → Mathlib.Tactic.Abel.NormalExpr → Mathlib.Tactic.Abel.M (Mathlib.Tactic.Abel.NormalExpr × Lean.Expr) | true |
AlgebraicGeometry.topologically | Mathlib.AlgebraicGeometry.Morphisms.Constructors | ({α β : Type u} → [TopologicalSpace α] → [TopologicalSpace β] → (α → β) → Prop) →
CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme | true |
CategoryTheory.MonoidalCategory.LawfulDayConvolutionMonoidalCategoryStruct.convolutionExtensionUnit_comp_ι_map_whiskerLeft_app | Mathlib.CategoryTheory.Monoidal.DayConvolution | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} (V : Type u₂) {inst_1 : CategoryTheory.Category.{v₂, u₂} V}
{inst_2 : CategoryTheory.MonoidalCategory C} {inst_3 : CategoryTheory.MonoidalCategory V} {D : Type u₃}
{inst_4 : CategoryTheory.Category.{v₃, u₃} D} {inst_5 : CategoryTheory.MonoidalCategoryStruc... | true |
_private.Mathlib.Combinatorics.SimpleGraph.DegreeSum.0.SimpleGraph.dart_card_eq_sum_degrees._simp_1_1 | Mathlib.Combinatorics.SimpleGraph.DegreeSum | ∀ {α : Type u_1} [inst : Fintype α], Fintype.card α = Finset.univ.card | false |
_private.Init.Data.List.ToArray.0.Array.erase.match_1.splitter | Init.Data.List.ToArray | {α : Type u_1} →
(as : Array α) →
(motive : Option (Fin as.size) → Sort u_2) →
(x : Option (Fin as.size)) → (Unit → motive none) → ((i : Fin as.size) → motive (some i)) → motive x | true |
_aux_Mathlib_Data_Int_Notation___macroRules_termℤ_1 | Mathlib.Data.Int.Notation | Lean.Macro | false |
_private.Mathlib.Tactic.Basic.0.Mathlib.Tactic.evalIntrov.introsDep.match_1 | Mathlib.Tactic.Basic | (motive : Lean.Expr → Sort u_1) →
(t : Lean.Expr) →
((binderName : Lean.Name) →
(binderType e : Lean.Expr) →
(binderInfo : Lean.BinderInfo) → motive (Lean.Expr.forallE binderName binderType e binderInfo)) →
((x : Lean.Expr) → motive x) → motive t | false |
ChainCompletePartialOrder.IsExtremePt.mem_bot_iff_isExtremePt | Mathlib.Order.BourbakiWitt | ∀ {α : Type u_1} [inst : ChainCompletePartialOrder α] {x : α} {f : α → α} {y : α},
(∀ (x : α), x ≤ f x) → (y ∈ ChainCompletePartialOrder.bot x f ↔ ChainCompletePartialOrder.IsExtremePt x f y) | true |
Thunk.get_pure | Mathlib.Lean.Thunk | ∀ {α : Type u_1} (x : α), (Thunk.pure x).get = x | true |
CategoryTheory.Limits.IsZero.isoIsInitial | Mathlib.CategoryTheory.Limits.Shapes.ZeroObjects | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X Y : C} → CategoryTheory.Limits.IsZero X → CategoryTheory.Limits.IsInitial Y → (X ≅ Y) | true |
ContinuousLinearMap.compContinuousMultilinearMapL._proof_9 | Mathlib.Topology.Algebra.Module.Multilinear.Topology | ∀ (𝕜 : Type u_1) {ι : Type u_4} (E : ι → Type u_3) (G : Type u_2) [inst : NormedField 𝕜]
[inst_1 : (i : ι) → TopologicalSpace (E i)] [inst_2 : (i : ι) → AddCommGroup (E i)]
[inst_3 : (i : ι) → Module 𝕜 (E i)] [inst_4 : AddCommGroup G] [inst_5 : Module 𝕜 G] [inst_6 : TopologicalSpace G]
[inst_7 : IsTopological... | false |
Fin.val_pred | Init.Data.Fin.Lemmas | ∀ {n : ℕ} (j : Fin (n + 1)) (h : j ≠ 0), ↑(j.pred h) = ↑j - 1 | true |
Subtype.totallyDisconnectedSpace | Mathlib.Topology.Connected.TotallyDisconnected | ∀ {α : Type u_3} {p : α → Prop} [inst : TopologicalSpace α] [TotallyDisconnectedSpace α],
TotallyDisconnectedSpace (Subtype p) | true |
Lean.Grind.instAddFinCoOfNatIntCast | Init.GrindInstances.ToInt | ∀ {n : ℕ}, Lean.Grind.ToInt.Add (Fin n) (Lean.Grind.IntInterval.co 0 ↑n) | true |
_private.Mathlib.MeasureTheory.Measure.MeasureSpaceDef.0.MeasureTheory.exists_measurable_superset._simp_1_1 | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α} (s : Set α), μ.trim s = μ s | false |
Submodule.quotientEquivDirectSum | Mathlib.LinearAlgebra.FreeModule.Finite.Quotient | {ι : Type u_1} →
{R : Type u_2} →
{M : Type u_3} →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] →
[inst_2 : Module R M] →
[inst_3 : IsDomain R] →
[inst_4 : IsPrincipalIdealRing R] →
[inst_5 : Finite ι] →
(F : Type u_4) →
... | true |
_private.Init.Data.SInt.Lemmas.0.Int8.lt_of_lt_of_le._simp_1_1 | Init.Data.SInt.Lemmas | ∀ {x y : Int8}, (x ≤ y) = (x.toInt ≤ y.toInt) | false |
Lean.Meta.Rewrites.RewriteResult.addSuggestion | Lean.Meta.Tactic.Rewrites | Lean.Syntax →
Lean.Meta.Rewrites.RewriteResult → optParam (Option Lean.Elab.Tactic.SavedState) none → Lean.Elab.Tactic.TacticM Unit | true |
Batteries.TransOrd.eq_1 | Batteries.Classes.Deprecated | ∀ (α : Type u_1) [inst : Ord α], Batteries.TransOrd α = Batteries.TransCmp compare | true |
CategoryTheory.Limits.BinaryBicones.ext._auto_5 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | Lean.Syntax | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.