name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Associates.instOrderTop | Mathlib.Algebra.GroupWithZero.Associated | {M : Type u_1} → [inst : CommMonoidWithZero M] → OrderTop (Associates M) | true |
_private.Mathlib.Tactic.NormNum.Result.0.Mathlib.Meta.NormNum.IsNNRat.to_isRat.match_1_1 | Mathlib.Tactic.NormNum.Result | ∀ {α : Type u_1} [inst : Ring α] (motive : (x : α) → (x_1 x_2 : ℕ) → Mathlib.Meta.NormNum.IsNNRat x x_1 x_2 → Prop)
(x : α) (x_1 x_2 : ℕ) (x_3 : Mathlib.Meta.NormNum.IsNNRat x x_1 x_2),
(∀ (num denom : ℕ) (inv : Invertible ↑denom), motive (↑num * ⅟↑denom) num denom ⋯) → motive x x_1 x_2 x_3 | false |
CategoryTheory.ShortComplex.kernelSequence_exact | Mathlib.Algebra.Homology.ShortComplex.Exact | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C] {X Y : C}
(f : X ⟶ Y), (CategoryTheory.ShortComplex.kernelSequence f).Exact | true |
_private.Mathlib.NumberTheory.RatFunc.Ostrowski.0.RatFunc.irreducible_min_polynomial_valuation_lt_one_and_ne_zero._proof_1_7 | Mathlib.NumberTheory.RatFunc.Ostrowski | ∀ {K : Type u_2} {Γ : Type u_1} [inst : Field K] [inst_1 : LinearOrderedCommGroupWithZero Γ]
{v : Valuation (RatFunc K) Γ} [Valuation.IsTrivialOn K v] (a : K),
v ((algebraMap K (RatFunc K)) a) < 1 ∧ Polynomial.C a ≠ 0 → a ≠ 0 → False | false |
Std.IterM.toArray_filterMapM_mapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β γ δ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {o : Type w → Type w'''} [inst : Monad m]
[LawfulMonad m] [inst_2 : Monad n] [inst_3 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n]
[inst_6 : Monad o] [inst_7 : MonadAttach o] [LawfulMonad o] [WeaklyLawfulMonadAttach o] [inst_10 : Mon... | true |
CategoryTheory.Functor.mapProjectiveResolution | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {C : Type u} →
[inst : CategoryTheory.Category.{v_1, u} C] →
[inst_1 : CategoryTheory.Limits.HasZeroObject C] →
[inst_2 : CategoryTheory.Preadditive C] →
{D : Type u'} →
[inst_3 : CategoryTheory.Category.{v', u'} D] →
[inst_4 : CategoryTheory.Limits.HasZeroObject D] →
... | true |
Lean.Elab.Term.Do.ToCodeBlock.getTryCatchUpdatedVars | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock →
Array Lean.Elab.Term.Do.ToCodeBlock.Catch → Option Lean.Elab.Term.Do.CodeBlock → Lean.Elab.Term.Do.VarSet | true |
locallyFinite_iff_smallSets | Mathlib.Topology.LocallyFinite | ∀ {ι : Type u_1} {X : Type u_4} [inst : TopologicalSpace X] {f : ι → Set X},
LocallyFinite f ↔ ∀ (x : X), ∀ᶠ (s : Set X) in (nhds x).smallSets, {i | (f i ∩ s).Nonempty}.Finite | true |
_private.Lean.Meta.Basic.0.Lean.Meta.instantiateLambdaAux | Lean.Meta.Basic | Array Lean.Expr → ℕ → Lean.Expr → Lean.MetaM Lean.Expr | true |
_private.Init.Data.Int.Lemmas.0.Int.mul_add.match_1_1 | Init.Data.Int.Lemmas | ∀ (motive : ℤ → ℤ → ℤ → Prop) (x x_1 x_2 : ℤ),
(∀ (m n k : ℕ), motive (Int.ofNat m) (Int.ofNat n) (Int.ofNat k)) →
(∀ (m n k : ℕ), motive (Int.ofNat m) (Int.ofNat n) (Int.negSucc k)) →
(∀ (m n k : ℕ), motive (Int.ofNat m) (Int.negSucc n) (Int.ofNat k)) →
(∀ (m n k : ℕ), motive (Int.ofNat m) (Int.neg... | false |
LieHom.mk.noConfusion | Mathlib.Algebra.Lie.Basic | {R : Type u_1} →
{L : Type u_2} →
{L' : Type u_3} →
{inst : CommRing R} →
{inst_1 : LieRing L} →
{inst_2 : LieAlgebra R L} →
{inst_3 : LieRing L'} →
{inst_4 : LieAlgebra R L'} →
{P : Sort u} →
{toLinearMap : L →ₗ[R] L'} →
... | false |
_private.Init.Data.Fin.Fold.0.Fin.foldl.loop._unary | Init.Data.Fin.Fold | {α : Sort u_1} → (n : ℕ) → (α → Fin n → α) → (_ : α) ×' ℕ → α | false |
NonUnitalStarSubalgebra.inclusion_mk | Mathlib.Algebra.Star.NonUnitalSubalgebra | ∀ {R : Type u} {A : Type v} [inst : CommSemiring R] [inst_1 : NonUnitalSemiring A] [inst_2 : StarRing A]
[inst_3 : Module R A] {S T : NonUnitalStarSubalgebra R A} (h : S ≤ T) (x : A) (hx : x ∈ S),
(NonUnitalStarSubalgebra.inclusion h) ⟨x, hx⟩ = ⟨x, ⋯⟩ | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.IsTopologicalBasis.vietoris._proof_1_12 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} ⦃u : Set (Set α)⦄,
∀ s ⊆ ⋃₀ u,
∀ (f : Set α → Set α),
(∀ U ∈ u, (s ∩ f U).Nonempty) → s ∈ {s | s ⊆ (⋃₀ u, f '' u).1 ∧ ∀ U ∈ (⋃₀ u, f '' u).2, (s ∩ U).Nonempty} | false |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux.match_1_1 | Mathlib.Algebra.Lie.Weights.IsSimple | ∀ {K : Type u_1} {L : Type u_2} [inst : Field K] [inst_1 : LieRing L] [inst_2 : LieAlgebra K L]
[inst_3 : FiniteDimensional K L] {H : LieSubalgebra K L} [inst_4 : H.IsCartanSubalgebra]
(S : RootPairing (↥LieSubalgebra.root) K (Module.Dual K ↥H) ↥H) (i j : ↥LieSubalgebra.root)
(motive : S.root i + S.root j ∈ Set.r... | false |
_private.Lean.Meta.Tactic.Grind.Arith.EvalNum.0.Lean.Meta.Grind.Arith.evalNatCore._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.EvalNum | Lean.Expr → OptionT Lean.Meta.Grind.GrindM ℕ | false |
_private.Lean.Elab.Deriving.ToExpr.0.Lean.Elab.Deriving.ToExpr.mkLocalInstanceLetDecls | Lean.Elab.Deriving.ToExpr | Lean.Elab.Deriving.Context →
Array Lean.Name → Array Lean.Term → Lean.Elab.TermElabM (Array (Lean.TSyntax `Lean.Parser.Term.letDecl)) | true |
_private.Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential.0.UniqueMDiffWithinAt.bundle_preimage_aux._simp_1_3 | Mathlib.Geometry.Manifold.MFDeriv.UniqueDifferential | ∀ {α : Type u} {ι : Sort u_1} {f : ι → α} {x : α}, (x ∈ Set.range f) = ∃ y, f y = x | false |
CompleteSublattice.instInfSet | Mathlib.Order.CompleteSublattice | {α : Type u_1} → [inst : CompleteLattice α] → {L : CompleteSublattice α} → InfSet ↥L | true |
_private.Mathlib.Algebra.Polynomial.Module.Basic.0.PolynomialModule.smul_single_apply._proof_1_1 | Mathlib.Algebra.Polynomial.Module.Basic | ∀ {R : Type u_2} {M : Type u_1} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M] (i : ℕ) (m : M)
(n n_1 : ℕ) (a : R),
((Polynomial.monomial n_1) a • (PolynomialModule.single R i) m) n =
if i ≤ n then ((Polynomial.monomial n_1) a).coeff (n - i) • m else 0 | false |
ProbabilityTheory.Kernel.measurable_kernel_prodMk_right | Mathlib.Probability.Kernel.MeasurableLIntegral | ∀ {α : Type u_1} {β : Type u_2} {mα : MeasurableSpace α} {mβ : MeasurableSpace β} {κ : ProbabilityTheory.Kernel α β}
[ProbabilityTheory.IsSFiniteKernel κ] {s : Set (β × α)},
MeasurableSet s → Measurable fun y => (κ y) ((fun x => (x, y)) ⁻¹' s) | true |
CategoryTheory.Comonad.recOn | Mathlib.CategoryTheory.Monad.Basic | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{motive : CategoryTheory.Comonad C → Sort u} →
(t : CategoryTheory.Comonad C) →
((toFunctor : CategoryTheory.Functor C C) →
(ε : toFunctor ⟶ CategoryTheory.Functor.id C) →
(δ : toFunctor ⟶ toFunctor.comp toFuncto... | false |
Valuation.isOpen_ball | Mathlib.Topology.Algebra.ValuativeRel.ValuativeTopology | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] {Γ₀ : Type u_3}
[inst_2 : LinearOrderedCommGroupWithZero Γ₀] [_t : TopologicalSpace R] [IsValuativeTopology R] {v : Valuation R Γ₀}
[v.Compatible] (r : MonoidWithZeroHom.ValueGroup₀ v), IsOpen {x | v.restrict x < r} | true |
Fin.coe_ofNat_eq_mod | Mathlib.Data.Fin.Basic | ∀ (m n : ℕ) [inst : NeZero m], ↑(OfNat.ofNat n) = OfNat.ofNat n % m | true |
Homeomorph.smul.congr_simp | Mathlib.Topology.Algebra.Group.Basic | ∀ {α : Type u_2} {G : Type u_4} [inst : TopologicalSpace α] [inst_1 : Group G] [inst_2 : MulAction G α]
[inst_3 : ContinuousConstSMul G α] (γ γ_1 : G), γ = γ_1 → Homeomorph.smul γ = Homeomorph.smul γ_1 | true |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.tendsto_of_integral_tendsto_of_monotone._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {α : Type u_1} [inst : LE α] [inst_1 : Add α] [inst_2 : Sub α] [OrderedSub α] {a b c : α}, (a - b ≤ c) = (a ≤ c + b) | false |
_private.Mathlib.Algebra.Lie.BaseChange.0.LieAlgebra.ExtendScalars.bracket'._proof_7 | Mathlib.Algebra.Lie.BaseChange | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | false |
Std.DTreeMap.Internal.Impl.contains_union!_of_right | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {m₁ m₂ : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α],
m₁.WF →
m₂.WF →
∀ {k : α},
Std.DTreeMap.Internal.Impl.contains k m₂ = true → Std.DTreeMap.Internal.Impl.contains k (m₁.union! m₂) = true | true |
IntervalIntegrable.log._simp_1 | Mathlib.Analysis.SpecialFunctions.Integrability.Basic | ∀ {a b : ℝ} {f : ℝ → ℝ} {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsLocallyFiniteMeasure μ],
ContinuousOn f (Set.uIcc a b) →
(∀ x ∈ Set.uIcc a b, f x ≠ 0) → IntervalIntegrable (fun x => Real.log (f x)) μ a b = True | false |
SchwartzMap.compCLMOfContinuousLinearEquiv._proof_1 | Mathlib.Analysis.Distribution.SchwartzSpace.Basic | ∀ {D : Type u_1} {E : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup D]
[inst_3 : NormedSpace ℝ D] (g : D ≃L[ℝ] E), Function.HasTemperateGrowth ⇑↑g | false |
CategoryTheory.Limits.Concrete.colimit_exists_rep | Mathlib.CategoryTheory.Limits.ConcreteCategory.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {FC : C → C → Type u_1} {CC : C → Type t}
[inst_1 : (X Y : C) → FunLike (FC X Y) (CC X) (CC Y)] [inst_2 : CategoryTheory.ConcreteCategory C FC] {J : Type w}
[inst_3 : CategoryTheory.Category.{r, w} J] (F : CategoryTheory.Functor J C)
[CategoryTheory.Limits.... | true |
Holor.instAddGroup._aux_1 | Mathlib.Data.Holor | {α : Type} → {ds : List ℕ} → [AddGroup α] → Holor α ds → Holor α ds → Holor α ds | false |
CategoryTheory.Abelian.SpectralObject.kernelSequenceOpcycles | Mathlib.Algebra.Homology.SpectralObject.Cycles | {C : Type u_1} →
{ι : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} ι] →
[inst_2 : CategoryTheory.Abelian C] →
CategoryTheory.Abelian.SpectralObject C ι →
{i j k : ι} →
(f : i ⟶ j) →
(g : j... | true |
Function.Bijective.comp_left | Mathlib.Logic.Function.Basic | ∀ {α : Sort u} {β : Sort v} {γ : Sort w} {g : β → γ}, Function.Bijective g → Function.Bijective fun x => g ∘ x | true |
Std.Tactic.BVDecide.BVExpr.bitblast.blastArithShiftRightConst | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.ShiftRight | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {w : ℕ} → (aig : Std.Sat.AIG α) → aig.ShiftTarget w → Std.Sat.AIG.RefVecEntry α w | true |
Asymptotics.IsLittleO.add_iff_left | Mathlib.Analysis.Asymptotics.Defs | ∀ {α : Type u_1} {F : Type u_4} {E' : Type u_6} [inst : Norm F] [inst_1 : SeminormedAddCommGroup E'] {g : α → F}
{l : Filter α} {f₁ f₂ : α → E'}, f₂ =o[l] g → ((fun x => f₁ x + f₂ x) =o[l] g ↔ f₁ =o[l] g) | true |
ShareCommon.StateFactoryImpl._sizeOf_inst | Init.ShareCommon | SizeOf ShareCommon.StateFactoryImpl | false |
Lean.Meta.Grind.Arith.Linear.Struct.elimEqs._default | Lean.Meta.Tactic.Grind.Arith.Linear.Types | Lean.PersistentArray (Option Lean.Meta.Grind.Arith.Linear.EqCnstr) | false |
uniqueDiffWithinAt_Iic | Mathlib.Analysis.Calculus.TangentCone.Real | ∀ (x : ℝ), UniqueDiffWithinAt ℝ (Set.Iic x) x | true |
FiniteArchimedeanClass.ballAddSubgroup | Mathlib.Algebra.Order.Archimedean.Class | {M : Type u_1} →
[inst : AddCommGroup M] →
[inst_1 : LinearOrder M] → [inst_2 : IsOrderedAddMonoid M] → FiniteArchimedeanClass M → AddSubgroup M | true |
Nat.Coprime.gcd_both | Init.Data.Nat.Coprime | ∀ {m n : ℕ} (k l : ℕ), m.Coprime n → (k.gcd m).Coprime (l.gcd n) | true |
Stream'.WSeq.ret_bind | Mathlib.Data.WSeq.Relation | ∀ {α : Type u} {β : Type v} (a : α) (f : α → Stream'.WSeq β), (Stream'.WSeq.ret a).bind f ~ʷ f a | true |
AlgebraicGeometry.SheafedSpace.IsOpenImmersion.ofRestrict_invApp_apply | Mathlib.Geometry.RingedSpace.OpenImmersion | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] (X : AlgebraicGeometry.SheafedSpace C) {Y : TopCat}
{f : Y ⟶ TopCat.of ↑↑X.toPresheafedSpace} (h : Topology.IsOpenEmbedding ⇑(CategoryTheory.ConcreteCategory.hom f))
(U : TopologicalSpace.Opens ↑↑(X.restrict h).toPresheafedSpace) {F : C → C → Type uF} {... | true |
Std.TreeSet.get_eq_get! | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} [Std.TransCmp cmp] [inst : Inhabited α] {a : α}
{h : a ∈ t}, t.get a h = t.get! a | true |
Lean.Lsp.LeanImportKind | Lean.Data.Lsp.Extra | Type | true |
Ordnode.Valid'.sz | Mathlib.Data.Ordmap.Ordset | ∀ {α : Type u_1} [inst : Preorder α] {lo : WithBot α} {t : Ordnode α} {hi : WithTop α}, Ordnode.Valid' lo t hi → t.Sized | true |
Vector.pmap_empty | Init.Data.Vector.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} {f : (a : α) → P a → β}, Vector.pmap f #v[] ⋯ = #v[] | true |
_private.Mathlib.Analysis.Complex.Hadamard.0.Complex.HadamardThreeLines.sSupNormIm_scale_left._simp_1_5 | Mathlib.Analysis.Complex.Hadamard | ∀ {α : Type u_1} {a b : α}, (a ∈ {b}) = (a = b) | false |
_private.Init.Data.List.ToArray.0.List.findSomeM?.eq_def | Init.Data.List.ToArray | ∀ {m : Type u → Type v} [inst : Monad m] {α : Type w} {β : Type u} (f : α → m (Option β)) (x : List α),
List.findSomeM? f x =
match x with
| [] => pure none
| a :: as => do
let __do_lift ← f a
match __do_lift with
| some b => pure (some b)
| none => List.findSomeM? f as | true |
Finset.orderIsoOfFin | Mathlib.Data.Finset.Sort | {α : Type u_1} → [inst : LinearOrder α] → (s : Finset α) → {k : ℕ} → s.card = k → Fin k ≃o ↥s | true |
Lean.initFn._@.Lean.Modifiers.2938752216._hygCtx._hyg.2 | Lean.Modifiers | IO Lean.TagDeclarationExtension | false |
ForInStep.ctorElim | Init.Core | {α : Type u} →
{motive : ForInStep α → Sort u_1} →
(ctorIdx : ℕ) → (t : ForInStep α) → ctorIdx = t.ctorIdx → ForInStep.ctorElimType ctorIdx → motive t | false |
Nat.toArray_ric_eq_singleton_iff._simp_1 | Init.Data.Range.Polymorphic.NatLemmas | ∀ {k n : ℕ}, ((*...=n).toArray = #[k]) = (n = 0 ∧ 0 = k) | false |
CategoryTheory.Limits.IsIPC | Mathlib.CategoryTheory.Limits.FilteredColimitCommutesProduct | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasProducts C] → [CategoryTheory.Limits.HasFilteredColimitsOfSize.{w, w, v, u} C] → Prop | true |
List.nodup_idxsOf._simp_1 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {x : α} {s : ℕ} [inst : BEq α], (List.idxsOf x xs s).Nodup = True | false |
MonadLift.recOn | Init.Prelude | {m : Type u → Type v} →
{n : Type u → Type w} →
{motive : MonadLift m n → Sort u_1} →
(t : MonadLift m n) → ((monadLift : {α : Type u} → m α → n α) → motive { monadLift := monadLift }) → motive t | false |
Turing.PartrecToTM2.Λ'.instDecidableEq._proof_35 | Mathlib.Computability.TuringMachine.ToPartrec | ∀ (k : Turing.PartrecToTM2.K') (s : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ')
(q q_1 : Turing.PartrecToTM2.Λ'), Turing.PartrecToTM2.Λ'.push k s q = q_1.copy → False | false |
CategoryTheory.ObjectProperty.rightOrthogonal | Mathlib.CategoryTheory.ObjectProperty.Orthogonal | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
[CategoryTheory.Limits.HasZeroMorphisms C] → CategoryTheory.ObjectProperty C → CategoryTheory.ObjectProperty C | true |
Std.IterM.foldl_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type u_1} {γ α β : Type w} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_4 : Std.IteratorLoop α m m] [Std.LawfulIteratorLoop α m m] {it : Std.IterM m β}
{f : γ → β → γ} {init : γ}, (fun x => List.foldl f init x) <$> it.toList = Std.IterM.fold f init ... | true |
QPF.mk | Mathlib.Data.QPF.Univariate.Basic | {F : Type u → Type v} →
[toFunctor : Functor F] →
(P : PFunctor.{u, u'}) →
(abs : {α : Type u} → ↑P α → F α) →
(repr : {α : Type u} → F α → ↑P α) →
(∀ {α : Type u} (x : F α), abs (repr x) = x) →
(∀ {α β : Type u} (f : α → β) (p : ↑P α), abs (P.map f p) = f <$> abs p) → QPF F | true |
CategoryTheory.TransfiniteCompositionOfShape.ofOrderIso_isColimit | Mathlib.CategoryTheory.Limits.Shapes.Preorder.TransfiniteCompositionOfShape | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : LinearOrder J] [inst_2 : OrderBot J]
{X Y : C} {f : X ⟶ Y} [inst_3 : SuccOrder J] [inst_4 : WellFoundedLT J]
(c : CategoryTheory.TransfiniteCompositionOfShape J f) {J' : Type w'} [inst_5 : LinearOrder J'] [inst_6 : OrderBot J']
[inst_... | true |
Std.Internal.IO.Process.ResourceUsageStats.recOn | Std.Internal.Async.Process | {motive : Std.Internal.IO.Process.ResourceUsageStats → Sort u} →
(t : Std.Internal.IO.Process.ResourceUsageStats) →
((cpuUserTime cpuSystemTime : Std.Time.Millisecond.Offset) →
(peakResidentSetSizeKb sharedMemorySizeKb unsharedDataSizeKb unsharedStackSizeKb minorPageFaults majorPageFaults
swap... | false |
MonoidHom.rangeRestrict.eq_1 | Mathlib.Algebra.Group.Subgroup.Ker | ∀ {G : Type u_1} [inst : Group G] {N : Type u_5} [inst_1 : Group N] (f : G →* N),
f.rangeRestrict = f.codRestrict f.range ⋯ | true |
Lean.Doc.given.getArgs | Lean.Elab.DocString.Builtin | Lean.TSyntaxArray `inline → StateT (Array (Lean.TSyntax `doc_arg)) Lean.Doc.DocM (Lean.Doc.Inline Lean.ElabInline) | true |
_private.Lean.DocString.Parser.0.Lean.Doc.Parser.codeBlock.withIndentColumn.match_1 | Lean.DocString.Parser | (motive : Option ℕ → Sort u_1) →
(x : Option ℕ) → ((colNat : ℕ) → motive (some colNat)) → ((x : Option ℕ) → motive x) → motive x | false |
MvPowerSeries.substAlgHom._proof_5 | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {τ : Type u_2} {S : Type u_1}, T2Space (MvPowerSeries τ S) | false |
SubfieldClass.toField._proof_35 | Mathlib.Algebra.Field.Subfield.Defs | ∀ (S : Type u_2) {K : Type u_1} [inst : Field K] [inst_1 : SetLike S K] [inst_2 : SubfieldClass S K] (s : S) (x : ↥s)
(x_1 : ℤ), ↑(x ^ x_1) = ↑(x ^ x_1) | false |
_private.Mathlib.MeasureTheory.Measure.FiniteMeasure.0.MeasureTheory.FiniteMeasure.continuous_iff_forall_continuous_integral._simp_1_1 | Mathlib.MeasureTheory.Measure.FiniteMeasure | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
Continuous f = ∀ (x : X), ContinuousAt f x | false |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.size_assignments_confirmRupHint._proof_1_9 | Std.Tactic.BVDecide.LRAT.Internal.Formula.RupAddResult | ∀ {n : ℕ} (assignments : Array Std.Tactic.BVDecide.LRAT.Internal.Assignment)
(l : Std.Tactic.BVDecide.LRAT.Internal.PosFin n), ↑l + 1 ≤ assignments.size → ↑l < assignments.size | false |
Set.powersetCard.mulActionHom_singleton_bijective | Mathlib.GroupTheory.GroupAction.SubMulAction.Combination | ∀ (G : Type u_1) [inst : Group G] (α : Type u_2) [inst_1 : MulAction G α] [inst_2 : DecidableEq α],
Function.Bijective ⇑(Set.powersetCard.mulActionHom_singleton G α) | true |
Set.pi_eq_empty_iff' | Mathlib.Data.Set.Prod | ∀ {ι : Type u_1} {α : ι → Type u_2} {s : Set ι} {t : (i : ι) → Set (α i)} [∀ (i : ι), Nonempty (α i)],
s.pi t = ∅ ↔ ∃ i ∈ s, t i = ∅ | true |
SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint.rec | Mathlib.Combinatorics.SimpleGraph.Triangle.Tripartite | {α : Type u_1} →
{β : Type u_2} →
{γ : Type u_3} →
{t : Finset (α × β × γ)} →
{motive : SimpleGraph.TripartiteFromTriangles.ExplicitDisjoint t → Sort u} →
((inj₀ : ∀ ⦃a : α⦄ ⦃b : β⦄ ⦃c : γ⦄ ⦃a' : α⦄, (a, b, c) ∈ t → (a', b, c) ∈ t → a = a') →
(inj₁ : ∀ ⦃a : α⦄ ⦃b : β⦄ ⦃c : γ⦄... | false |
CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork_inverse_obj_ι | Mathlib.CategoryTheory.Limits.Shapes.Multiequalizer | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (J : CategoryTheory.Limits.MulticospanShape)
[inst_1 : Unique J.L] [inst_2 : Unique J.R] {X Y : C} (f g : X ⟶ Y) (c : CategoryTheory.Limits.Fork f g) (a : J.L),
((CategoryTheory.Limits.MulticospanIndex.multiforkOfParallelHomsEquivFork J f g).inverse.obj c).ι ... | true |
Real.toNNReal_lt_toNNReal_iff'._simp_1 | Mathlib.Data.NNReal.Defs | ∀ {r p : ℝ}, (r.toNNReal < p.toNNReal) = (r < p ∧ 0 < p) | false |
Std.DTreeMap.Raw.getD_insert | Std.Data.DTreeMap.Raw.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap.Raw α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp],
t.WF →
∀ {k a : α} {fallback : β a} {v : β k},
(t.insert k v).getD a fallback = if h : cmp k a = Ordering.eq then cast ⋯ v else t.getD a fallback | true |
Polynomial.aeval_mul | Mathlib.Algebra.Polynomial.AlgebraMap | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] {p q : Polynomial R}
(x : A), (Polynomial.aeval x) (p * q) = (Polynomial.aeval x) p * (Polynomial.aeval x) q | true |
CategoryTheory.Limits.limitObjIsoLimitCompEvaluation._proof_2 | Mathlib.CategoryTheory.Limits.FunctorCategory.Basic | ∀ {C : Type u_5} [inst : CategoryTheory.Category.{u_4, u_5} C] {J : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} J] {K : Type u_3} [inst_2 : CategoryTheory.Category.{u_6, u_3} K]
[CategoryTheory.Limits.HasLimitsOfShape J C] (F : CategoryTheory.Functor J (CategoryTheory.Functor K C)),
CategoryTheory.Limi... | false |
CategoryTheory.NatTrans.unop | Mathlib.CategoryTheory.Opposites | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
{F G : CategoryTheory.Functor Cᵒᵖ Dᵒᵖ} → (F ⟶ G) → (G.unop ⟶ F.unop) | true |
_private.Mathlib.Topology.Sets.VietorisTopology.0.IsClosed.powerset_vietoris._simp_1_3 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = (s ∩ tᶜ).Nonempty | false |
Std.Internal.List.getKey?_filter_containsKey_of_containsKey_eq_false_left | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [EquivBEq α] {l₁ l₂ : List ((a : α) × β a)} {k : α},
Std.Internal.List.DistinctKeys l₁ →
Std.Internal.List.containsKey k l₁ = false →
Std.Internal.List.getKey? k (List.filter (fun p => Std.Internal.List.containsKey p.fst l₂) l₁) = none | true |
Matroid.isFlat_closure | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} (X : Set α), M.IsFlat (M.closure X) | true |
_private.Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic.0.MeasureTheory.charFun_neg._simp_1_1 | Mathlib.MeasureTheory.Measure.CharacteristicFunction.Basic | ∀ {X : Type u_1} [inst : MeasurableSpace X] {μ : MeasureTheory.Measure X} {𝕜 : Type u_6} [inst_1 : RCLike 𝕜]
{f : X → 𝕜}, (starRingEnd 𝕜) (∫ (x : X), f x ∂μ) = ∫ (x : X), (starRingEnd 𝕜) (f x) ∂μ | false |
_private.Batteries.Data.List.Basic.0.List.all₂.match_1.splitter._sparseCasesOn_5 | Batteries.Data.List.Basic | {α : Type u} →
{motive : List α → Sort u_1} →
(t : List α) →
((head : α) → (tail : List α) → motive (head :: tail)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | false |
CategoryTheory.NormalMono.w | Mathlib.CategoryTheory.Limits.Shapes.NormalMono.Basic | ∀ {C : Type u₁} {inst : CategoryTheory.Category.{v₁, u₁} C} {X Y : C}
{inst_1 : CategoryTheory.Limits.HasZeroMorphisms C} {f : X ⟶ Y} [self : CategoryTheory.NormalMono f],
CategoryTheory.CategoryStruct.comp f CategoryTheory.NormalMono.g = 0 | true |
localCohomology.instCategorySelfLERadical._proof_9 | Mathlib.Algebra.Homology.LocalCohomology | ∀ {R : Type u_1} [inst : CommRing R] (J : Ideal R),
autoParam
(∀ {W X Y Z : localCohomology.SelfLERadical J} (f : W ⟶ X) (g : X ⟶ Y) (h : Y ⟶ Z),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp f g) h =
CategoryTheory.CategoryStruct.comp f (CategoryTheory.CategoryStruct.comp g... | false |
CategoryTheory.Limits.parallelFamily_obj_one | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} (f : J → (X ⟶ Y)),
(CategoryTheory.Limits.parallelFamily f).obj CategoryTheory.Limits.WalkingParallelFamily.one = Y | true |
UpperSet._sizeOf_inst | Mathlib.Order.Defs.Unbundled | (α : Type u_1) → {inst : LE α} → [SizeOf α] → SizeOf (UpperSet α) | false |
Matrix.GeneralLinearGroup.fixpointPolynomial | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | {R : Type u_1} → [inst : CommRing R] → GL (Fin 2) R → Polynomial R | true |
CategoryTheory.CostructuredArrow.mapIso_counitIso_hom_app_left | Mathlib.CategoryTheory.Comma.StructuredArrow.Basic | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{T T' : D} {S : CategoryTheory.Functor C D} (i : T ≅ T')
(X : CategoryTheory.Comma S (CategoryTheory.Functor.fromPUnit T')),
((CategoryTheory.CostructuredArrow.mapIso i).counitIso.hom.app X).lef... | true |
ArchimedeanClass.addValuation_apply | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] (a : R),
(ArchimedeanClass.addValuation R) a = ArchimedeanClass.mk a | true |
Finset.add_union | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Add α] {s t₁ t₂ : Finset α}, s + (t₁ ∪ t₂) = s + t₁ ∪ (s + t₂) | true |
PUnit.commRing._proof_8 | Mathlib.Algebra.Ring.PUnit | ∀ (n : ℕ), (Int.negSucc n).castDef = -↑(n + 1) | false |
IsUniformGroup.cauchy_map_iff_tendsto | Mathlib.Topology.Algebra.IsUniformGroup.Basic | ∀ {ι : Type u_3} {G : Type u_4} [inst : Group G] [inst_1 : UniformSpace G] [IsUniformGroup G] (𝓕 : Filter ι)
(f : ι → G), Cauchy (Filter.map f 𝓕) ↔ 𝓕.NeBot ∧ Filter.Tendsto (fun p => f p.1 / f p.2) (𝓕 ×ˢ 𝓕) (nhds 1) | true |
Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs.injEq | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c c_1 : Lean.Meta.Grind.Arith.Cutsat.EqCnstr),
(Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs c = Lean.Meta.Grind.Arith.Cutsat.EqCnstrProof.divCoeffs c_1) =
(c = c_1) | true |
ModuleCat.exteriorPower.iso₀_hom_naturality | Mathlib.Algebra.Category.ModuleCat.ExteriorPower | ∀ {R : Type u} [inst : CommRing R] {M N : ModuleCat R} (f : M ⟶ N),
CategoryTheory.CategoryStruct.comp (ModuleCat.exteriorPower.map f 0) (ModuleCat.exteriorPower.iso₀ N).hom =
(ModuleCat.exteriorPower.iso₀ M).hom | true |
Lean.Elab.Command.elabCheckAssertions._regBuiltin.Lean.Elab.Command.elabCheckAssertions_1 | Lean.Elab.AssertExists | IO Unit | false |
VertexOperator._aux_Mathlib_Algebra_Vertex_VertexOperator___unexpand_VertexOperator_ncoeff_1 | Mathlib.Algebra.Vertex.VertexOperator | Lean.PrettyPrinter.Unexpander | false |
_private.Mathlib.MeasureTheory.Integral.Bochner.Basic.0.MeasureTheory.integral_div._simp_1_1 | Mathlib.MeasureTheory.Integral.Bochner.Basic | ∀ {G : Type u_1} [inst : DivInvMonoid G] (a b : G), a * b⁻¹ = a / b | false |
Std.Rxc.Iterator.instIteratorAccess | Init.Data.Range.Polymorphic.RangeIterator | {α : Type u} →
[inst : Std.PRange.UpwardEnumerable α] →
[inst_1 : LE α] →
[inst_2 : DecidableLE α] →
[Std.PRange.LawfulUpwardEnumerable α] →
[Std.PRange.LawfulUpwardEnumerableLE α] → Std.IteratorAccess (Std.Rxc.Iterator α) Id | true |
String.Slice.Pos.sliceTo_le_sliceTo_iff._simp_1 | Init.Data.String.Lemmas.Order | ∀ {s : String.Slice} {p₀ q r : s.Pos} {h₁ : q ≤ p₀} {h₂ : r ≤ p₀}, (p₀.sliceTo q h₁ ≤ p₀.sliceTo r h₂) = (q ≤ r) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.