name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CauSeq.Completion.instSMulCauchyOfIsScalarTower | Mathlib.Algebra.Order.CauSeq.Completion | {α : Type u_1} →
[inst : Field α] →
[inst_1 : LinearOrder α] →
[inst_2 : IsStrictOrderedRing α] →
{β : Type u_2} →
[inst_3 : Ring β] →
{abv : β → α} →
[inst_4 : IsAbsoluteValue abv] →
{γ : Type u_3} → [inst_5 : SMul γ β] → [IsScalarTower γ β β] → SMul γ (CauSeq.Completion.Cauchy abv) | true |
TopologicalSpace.OpenNhdsOf.ctorIdx | Mathlib.Topology.Sets.Opens | {α : Type u_2} → {inst : TopologicalSpace α} → {x : α} → TopologicalSpace.OpenNhdsOf x → ℕ | false |
AffineSubspace.span_univ | Mathlib.LinearAlgebra.AffineSpace.AffineSubspace.Defs | ∀ (k : Type u_1) (V : Type u_2) (P : Type u_3) [inst : Ring k] [inst_1 : AddCommGroup V] [inst_2 : Module k V]
[S : AddTorsor V P], affineSpan k Set.univ = ⊤ | true |
_private.Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction.0.CochainComplex.HomComplex.Cochain.InductionUp.limitSequence_eqUpTo._proof_1_1 | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexInduction | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {d : ℤ} {X : ℕ → Set (CochainComplex.HomComplex.Cochain K L d)} {p₀ : ℤ} (x₀ : ↑(X 0))
(n : ℕ), ∀ p ≤ p₀ + ↑n, (p - p₀).toNat ≤ n | false |
ZeroHom.instModule._proof_4 | Mathlib.Algebra.Module.Hom | ∀ {R : Type u_3} {A : Type u_1} {B : Type u_2} [inst : Semiring R] [inst_1 : AddMonoid A] [inst_2 : AddCommMonoid B]
[inst_3 : Module R B] (m : ZeroHom A B), 0 • m = 0 | false |
_private.Mathlib.Tactic.SplitIfs.0.Mathlib.Tactic.SplitPosition.rec | Mathlib.Tactic.SplitIfs | {motive : Mathlib.Tactic.SplitPosition✝ → Sort u} →
motive Mathlib.Tactic.SplitPosition.target✝ →
((fvarId : Lean.FVarId) → motive (Mathlib.Tactic.SplitPosition.hyp✝ fvarId)) →
(t : Mathlib.Tactic.SplitPosition✝¹) → motive t | false |
Batteries.CodeAction.getAllArgs._unsafe_rec | Batteries.CodeAction.Misc | Lean.Expr → Array Lean.Name → Array Lean.Name | false |
SpecialLinearGroup.congr_linearEquiv._proof_2 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] {W : Type u_3}
[inst_3 : AddCommGroup W] [inst_4 : Module R W] (e : V ≃ₗ[R] W) (g : SpecialLinearGroup R W),
LinearEquiv.det (e ≪≫ₗ ↑g ≪≫ₗ e.symm) = 1 | false |
Function.locallyFinsuppWithin.logCounting_strictMono | Mathlib.Analysis.Complex.ValueDistribution.LogCounting.Basic | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : DecidableEq E] [inst_2 : ProperSpace E]
{D : Function.locallyFinsupp E ℤ} {e : E},
Function.locallyFinsuppWithin.single e 1 ≤ D →
StrictMonoOn (Function.locallyFinsuppWithin.logCounting D) (Set.Ioi ‖e‖) | true |
_private.Mathlib.Topology.Bornology.Absorbs.0.absorbs_inter._simp_1_3 | Mathlib.Topology.Bornology.Absorbs | ∀ {α : Type u} {p q : α → Prop} {f : Filter α},
(∀ᶠ (x : α) in f, p x ∧ q x) = ((∀ᶠ (x : α) in f, p x) ∧ ∀ᶠ (x : α) in f, q x) | false |
Lean.Expr.updateLetE! | Lean.Expr | Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr → Lean.Expr | true |
_private.Mathlib.Analysis.Normed.Lp.lpSpace.0.LipschitzWith.coordinate._simp_1_1 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f = LipschitzOnWith K f Set.univ | false |
_private.Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas.0.Nat.nthRoot_eq_of_le_of_lt._proof_1_2 | Mathlib.Analysis.SpecialFunctions.Pow.NthRootLemmas | ∀ {n a b : ℕ}, a ≤ n.nthRoot b → n.nthRoot b < a + 1 → n.nthRoot b = a | false |
_private.Mathlib.Data.Nat.Fib.Basic.0.Nat.le_fib_add_one.match_1_1 | Mathlib.Data.Nat.Fib.Basic | ∀ (motive : ℕ → Prop) (x : ℕ),
(∀ (a : Unit), motive 0) →
(∀ (a : Unit), motive 1) →
(∀ (a : Unit), motive 2) →
(∀ (a : Unit), motive 3) →
(∀ (a : Unit), motive 4) → (∀ (_n : ℕ), motive _n.succ.succ.succ.succ.succ) → motive x | false |
Option.max_eq_none_iff._simp_1 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} [inst : Max α] {o o' : Option α}, (o ⊔ o' = none) = (o = none ∧ o' = none) | false |
Algebra.TensorProduct.equivFinsuppOfBasis_apply | Mathlib.LinearAlgebra.TensorProduct.Free | ∀ {R : Type u_1} (A : Type u_2) {V : Type u_3} [inst : CommSemiring A] [inst_1 : CommSemiring R] [inst_2 : Algebra R A]
[inst_3 : AddCommGroup V] [inst_4 : Module R V] {ι : Type u_4} (b : Module.Basis ι R V) (a : TensorProduct R A V),
(Algebra.TensorProduct.equivFinsuppOfBasis A b) a =
(TensorProduct.finsuppScalarRight R A A ι) ((LinearMap.baseChange A ↑b.repr) a) | true |
NFA.Path.nil.elim | Mathlib.Computability.NFA | {α : Type u} →
{σ : Type v} →
{M : NFA α σ} →
{motive : (a a_1 : σ) → (a_2 : List α) → M.Path a a_1 a_2 → Sort u_1} →
{a a_1 : σ} →
{a_2 : List α} →
(t : M.Path a a_1 a_2) → t.ctorIdx = 0 → ((s : σ) → motive s s [] (NFA.Path.nil s)) → motive a a_1 a_2 t | false |
Lean.Elab.Command.InductiveViewToCoinductiveElab | Lean.Elab.MutualInductive | Lean.Elab.Command.InductiveElabStep1 → Lean.Elab.Command.CoinductiveElabData | true |
ZeroAtInftyContinuousMap.instSub | Mathlib.Topology.ContinuousMap.ZeroAtInfty | {α : Type u} →
{β : Type v} →
[inst : TopologicalSpace α] →
[inst_1 : TopologicalSpace β] →
[inst_2 : AddGroup β] → [IsTopologicalAddGroup β] → Sub (ZeroAtInftyContinuousMap α β) | true |
Matroid.comap_map | Mathlib.Combinatorics.Matroid.Map | ∀ {α : Type u_1} {β : Type u_2} {M : Matroid α} {f : α → β} (hf : Function.Injective f), (M.map f ⋯).comap f = M | true |
Real.limsSup_of_not_isCobounded | Mathlib.Order.Filter.ENNReal | ∀ {f : Filter ℝ}, ¬Filter.IsCobounded (fun x1 x2 => x1 ≤ x2) f → f.limsSup = 0 | true |
NonUnitalStarSubalgebra.toNonUnitalRing | Mathlib.Algebra.Star.NonUnitalSubalgebra | {R : Type u_1} →
{A : Type u_2} →
[inst : CommRing R] →
[inst_1 : NonUnitalRing A] →
[inst_2 : Module R A] → [inst_3 : Star A] → (S : NonUnitalStarSubalgebra R A) → NonUnitalRing ↥S | true |
Localization.Away.mulEquivOfQuotient.eq_1 | Mathlib.GroupTheory.MonoidLocalization.Away | ∀ {M : Type u_1} [inst : CommMonoid M] {N : Type u_2} [inst_1 : CommMonoid N] (x : M)
(f : Submonoid.LocalizationMap.AwayMap x N),
Localization.Away.mulEquivOfQuotient x f = Localization.mulEquivOfQuotient f | true |
Lean.Parser.Command.declaration._regBuiltin.Lean.Parser.Command.structure.parenthesizer_361 | Lean.Parser.Command | IO Unit | false |
CategoryTheory.ConnectedComponents.typeToCatHomEquiv._proof_2 | Mathlib.CategoryTheory.ConnectedComponents | ∀ (J : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} J] (X : Type u_3)
(f : CategoryTheory.ConnectedComponents J → X),
CategoryTheory.ConnectedComponents.liftFunctor J (CategoryTheory.ConnectedComponents.functorToDiscrete X f) = f | false |
isClosed_setOf_lipschitzWith | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u_4} {β : Type u_5} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] (K : NNReal),
IsClosed {f | LipschitzWith K f} | true |
Measurable.const_inf | Mathlib.MeasureTheory.Order.Lattice | ∀ {M : Type u_1} [inst : MeasurableSpace M] {α : Type u_2} {m : MeasurableSpace α} {f : α → M} [inst_1 : Min M]
[MeasurableInf M], Measurable f → ∀ (c : M), Measurable fun x => c ⊓ f x | true |
Vector.getElem_eq_getElem?_get._proof_1 | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {i : ℕ}, i < n → xs[i]?.isSome = true | false |
CategoryTheory.ShortComplex.RightHomologyData.op._proof_2 | Mathlib.Algebra.Homology.ShortComplex.RightHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C}, CategoryTheory.CategoryStruct.comp S.op.f S.op.g = 0 | false |
PadicInt.mahlerSeries.congr_simp | Mathlib.NumberTheory.Padics.MahlerBasis | ∀ {p : ℕ} [hp : Fact (Nat.Prime p)] {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : Module ℤ_[p] E]
[inst_2 : IsBoundedSMul ℤ_[p] E] (a a_1 : ℕ → E), a = a_1 → PadicInt.mahlerSeries a = PadicInt.mahlerSeries a_1 | true |
Lean.Meta.Try.Collector.Context.mk | Lean.Meta.Tactic.Try.Collect | Lean.Try.Config → Lean.Meta.Try.Collector.Context | true |
Lean.IR.EmitLLVM.Context.mk.inj | Lean.Compiler.IR.EmitLLVM | ∀ {llvmctx : LLVM.Context} {env : Lean.Environment} {modName : Lean.Name} {jpMap : Lean.IR.JPParamsMap}
{mainFn : Lean.IR.FunId} {mainParams : Array Lean.IR.Param} {llvmmodule : LLVM.Module llvmctx}
{env_1 : Lean.Environment} {modName_1 : Lean.Name} {jpMap_1 : Lean.IR.JPParamsMap} {mainFn_1 : Lean.IR.FunId}
{mainParams_1 : Array Lean.IR.Param} {llvmmodule_1 : LLVM.Module llvmctx},
{ env := env, modName := modName, jpMap := jpMap, mainFn := mainFn, mainParams := mainParams,
llvmmodule := llvmmodule } =
{ env := env_1, modName := modName_1, jpMap := jpMap_1, mainFn := mainFn_1, mainParams := mainParams_1,
llvmmodule := llvmmodule_1 } →
env = env_1 ∧
modName = modName_1 ∧ jpMap = jpMap_1 ∧ mainFn = mainFn_1 ∧ mainParams = mainParams_1 ∧ llvmmodule = llvmmodule_1 | true |
DedekindCut.upperBounds_left | Mathlib.Order.Completion | ∀ {α : Type u_1} [inst : Preorder α] (A : DedekindCut α), upperBounds A.left = A.right | true |
CategoryTheory.MorphismProperty.Over.pullback._proof_5 | Mathlib.CategoryTheory.MorphismProperty.OverAdjunction | ∀ {T : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} T] (P Q : CategoryTheory.MorphismProperty T)
[inst_1 : Q.IsMultiplicative] {X Y : T} (f : X ⟶ Y) [inst_2 : P.HasPullbacksAlong f] {A B : P.Over Q Y} (g : A ⟶ B),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.fst A.hom f) g.left) B.hom =
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.pullback.snd A.hom f) f | false |
LinearMap.BilinForm.SeparatingRight.toMatrix' | Mathlib.LinearAlgebra.Matrix.BilinearForm | ∀ {R₂ : Type u_3} [inst : CommRing R₂] {ι : Type u_6} [inst_1 : DecidableEq ι] [inst_2 : Fintype ι]
{B : LinearMap.BilinForm R₂ (ι → R₂)}, LinearMap.SeparatingRight B → (LinearMap.BilinForm.toMatrix' B).SeparatingRight | true |
Finset.map_ssubset_map | Mathlib.Data.Finset.Image | ∀ {α : Type u_1} {β : Type u_2} {f : α ↪ β} {s t : Finset α}, Finset.map f s ⊂ Finset.map f t ↔ s ⊂ t | true |
_private.Lean.Server.FileWorker.SignatureHelp.0.Lean.Server.FileWorker.SignatureHelp.findSignatureHelp?.match_5 | Lean.Server.FileWorker.SignatureHelp | (motive : Lean.Server.FileWorker.SignatureHelp.SearchControl → Sort u_1) →
(control : Lean.Server.FileWorker.SignatureHelp.SearchControl) →
(Unit → motive Lean.Server.FileWorker.SignatureHelp.SearchControl.stop) →
((x : Lean.Server.FileWorker.SignatureHelp.SearchControl) → motive x) → motive control | false |
Filter.frequently_lt_of_lt_limsup | Mathlib.Order.LiminfLimsup | ∀ {α : Type u_1} {β : Type u_2} [inst : ConditionallyCompleteLinearOrder β] {f : Filter α} {u : α → β} {b : β},
autoParam (Filter.IsCoboundedUnder (fun x1 x2 => x1 ≤ x2) f u) Filter.frequently_lt_of_lt_limsup._auto_1 →
b < Filter.limsup u f → ∃ᶠ (x : α) in f, b < u x | true |
_private.Lean.AddDecl.0.Lean.registerNamePrefixes.match_1 | Lean.AddDecl | (motive : Lean.Name → Sort u_1) →
(x : Lean.Name) → ((p : Lean.Name) → (str : String) → motive (p.str str)) → ((x : Lean.Name) → motive x) → motive x | false |
antisymmetrization_fibration | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} [inst : Preorder α],
Relation.Fibration (fun x1 x2 => x1 < x2) (fun x1 x2 => x1 < x2) (toAntisymmetrization fun x1 x2 => x1 ≤ x2) | true |
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SizeState.ctorIdx | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.IntToBitVec | Lean.Elab.Tactic.BVDecide.Frontend.Normalize.SizeState → ℕ | false |
OrderedFinpartition.compAlongOrderedFinpartitionₗ._proof_2 | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_3} [inst : NontriviallyNormedField 𝕜] {E : Type u_1} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_4} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_2}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
(f : ContinuousMultilinearMap 𝕜 (fun i => F) G) (p : (i : Fin c.length) → ContinuousMultilinearMap 𝕜 (fun i => E) F)
(m : Fin c.length) (a : 𝕜) (q : ContinuousMultilinearMap 𝕜 (fun i => E) F),
(fun p => c.compAlongOrderedFinpartition f p) (Function.update p m (a • q)) =
a • (fun p => c.compAlongOrderedFinpartition f p) (Function.update p m q) | false |
MLList.foldsM | Batteries.Data.MLList.Basic | {m : Type u_1 → Type u_1} → {β α : Type u_1} → [Monad m] → (β → α → m β) → β → MLList m α → MLList m β | true |
Finset.card_pow_le | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Monoid α] {s : Finset α} {n : ℕ}, (s ^ n).card ≤ s.card ^ n | true |
CategoryTheory.Presieve.isSheafFor_singleton | Mathlib.CategoryTheory.Sites.IsSheafFor | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {P : CategoryTheory.Functor Cᵒᵖ (Type w)} {X Y : C}
{f : X ⟶ Y},
CategoryTheory.Presieve.IsSheafFor P (CategoryTheory.Presieve.singleton f) ↔
∀ (x : P.obj (Opposite.op X)),
(∀ {Z : C} (p₁ p₂ : Z ⟶ X),
CategoryTheory.CategoryStruct.comp p₁ f = CategoryTheory.CategoryStruct.comp p₂ f →
P.map p₁.op x = P.map p₂.op x) →
∃! y, P.map f.op y = x | true |
isClosed_preCantorSet | Mathlib.Topology.Instances.CantorSet | ∀ (n : ℕ), IsClosed (preCantorSet n) | true |
CategoryTheory.Limits.Types.instHasPushoutsType | Mathlib.CategoryTheory.Limits.Types.Pushouts | CategoryTheory.Limits.HasPushouts (Type u) | true |
CochainComplex.mappingCocone.inr_v_desc_f | Mathlib.Algebra.Homology.HomotopyCategory.MappingCocone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} (φ : K ⟶ L) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {M : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cochain K M 0) (β : CochainComplex.HomComplex.Cocycle L M 1)
(hαβ : CochainComplex.HomComplex.δ 0 1 α + (CochainComplex.HomComplex.Cochain.ofHom φ).comp ↑β ⋯ = 0) (p q : ℤ)
(hpq : p + 1 = q),
CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCocone.inr φ)).v p q hpq)
((CochainComplex.mappingCocone.desc φ α β hαβ).f q) =
(↑β).v p q hpq | true |
MulAction.rec | Mathlib.Algebra.Group.Action.Defs | {α : Type u_9} →
{β : Type u_10} →
[inst : Monoid α] →
{motive : MulAction α β → Sort u} →
([toSemigroupAction : SemigroupAction α β] →
(one_smul : ∀ (b : β), 1 • b = b) →
motive { toSemigroupAction := toSemigroupAction, one_smul := one_smul }) →
(t : MulAction α β) → motive t | false |
Topology.IsUpperSet.monotone_iff_continuous | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] [inst_2 : TopologicalSpace α]
[inst_3 : TopologicalSpace β] [Topology.IsUpperSet α] [Topology.IsUpperSet β] {f : α → β}, Monotone f ↔ Continuous f | true |
EquivLike.range_eq_univ | Mathlib.Logic.Equiv.Set | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : EquivLike E α β] (e : E), Set.range ⇑e = Set.univ | true |
Submodule.IsMinimalPrimaryDecomposition.primary | Mathlib.RingTheory.Lasker | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{N : Submodule R M} {t : Finset (Submodule R M)},
N.IsMinimalPrimaryDecomposition t → ∀ ⦃J : Submodule R M⦄, J ∈ t → J.IsPrimary | true |
instRightCancelMonoidSubtypeMemSubmonoidNonZeroDivisorsOfIsRightCancelMulZero._proof_1 | Mathlib.Algebra.GroupWithZero.NonZeroDivisors | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] (z x x_1 : ↥(nonZeroDivisors M₀)),
(fun x => x * z) x = (fun x => x * z) x_1 → ↑x * ↑z = ↑x_1 * ↑z | false |
SemiNormedGrp₁.str | Mathlib.Analysis.Normed.Group.SemiNormedGrp | (self : SemiNormedGrp₁) → SeminormedAddCommGroup self.carrier | true |
_private.Mathlib.Order.Interval.Set.WithBotTop.0.WithBot.preimage_coe_Ico._simp_1_1 | Mathlib.Order.Interval.Set.WithBotTop | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Ico a b = Set.Ici a ∩ Set.Iio b | false |
PartitionOfUnity.instFunLikeContinuousMapReal | Mathlib.Topology.PartitionOfUnity | {ι : Type u} → {X : Type v} → [inst : TopologicalSpace X] → {s : Set X} → FunLike (PartitionOfUnity ι X s) ι C(X, ℝ) | true |
_private.Mathlib.Tactic.ExtractGoal.0.Mathlib.Tactic.ExtractGoal.goalSignature.match_3 | Mathlib.Tactic.ExtractGoal | (motive : Lean.NameSet × Lean.Elab.Command.State → Sort u_1) →
(__discr : Lean.NameSet × Lean.Elab.Command.State) →
((ts : Lean.NameSet) → (snd : Lean.Elab.Command.State) → motive (ts, snd)) → motive __discr | false |
AddSubgroup.addSubgroupOfEquivOfLe_symm_apply_coe_coe | Mathlib.Algebra.Group.Subgroup.Map | ∀ {G : Type u_7} [inst : AddGroup G] {H K : AddSubgroup G} (h : H ≤ K) (g : ↥H),
↑↑((AddSubgroup.addSubgroupOfEquivOfLe h).symm g) = ↑g | true |
and_not_self._simp_1 | Init.SimpLemmas | ∀ {a : Prop}, (a ∧ ¬a) = False | false |
_private.Lean.Data.Array.0.Array.filterPairsM.match_3 | Lean.Data.Array | (motive : MProd ℕ (Array Bool) → Sort u_1) →
(r : MProd ℕ (Array Bool)) → ((numRemoved : ℕ) → (removed : Array Bool) → motive ⟨numRemoved, removed⟩) → motive r | false |
Aesop.ClusterState.AddM.Context | Aesop.Forward.State | Type | true |
AlternatingMap.continuous_of_bound | Mathlib.Analysis.Normed.Module.Alternating.Basic | ∀ {𝕜 : Type u} {E : Type wE} {F : Type wF} {ι : Type v} [inst : NontriviallyNormedField 𝕜]
[inst_1 : SeminormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : SeminormedAddCommGroup F]
[inst_4 : NormedSpace 𝕜 F] [inst_5 : Fintype ι] (f : E [⋀^ι]→ₗ[𝕜] F) (C : ℝ),
(∀ (m : ι → E), ‖f m‖ ≤ C * ∏ i, ‖m i‖) → Continuous ⇑f | true |
AddMonoid.Coprod.snd_comp_swap | Mathlib.GroupTheory.Coprod.Basic | ∀ {M : Type u_1} {N : Type u_2} [inst : AddMonoid M] [inst_1 : AddMonoid N],
AddMonoid.Coprod.snd.comp (AddMonoid.Coprod.swap M N) = AddMonoid.Coprod.fst | true |
IsLocalRing.spanFinrank_eq_finrank_quotient | Mathlib.Algebra.Module.SpanRankOperations | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_3} [inst_1 : AddCommGroup M] [inst_2 : Module R M]
[inst_3 : IsLocalRing R] (N : Submodule R M),
N.FG → N.spanFinrank = Module.finrank (R ⧸ IsLocalRing.maximalIdeal R) (↥N ⧸ IsLocalRing.maximalIdeal R • ⊤) | true |
Lean.Elab.Tactic.evalChoiceAux._unsafe_rec | Lean.Elab.Tactic.BuiltinTactic | Array Lean.Syntax → ℕ → Lean.Elab.Tactic.TacticM Unit | false |
Std.HashSet.Raw.union | Std.Data.HashSet.Raw | {α : Type u} → [BEq α] → [Hashable α] → Std.HashSet.Raw α → Std.HashSet.Raw α → Std.HashSet.Raw α | true |
CStarAlgebra.norm_le_iff_le_algebraMap._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Order | Lean.Syntax | false |
_private.Lean.Meta.Tactic.Simp.Types.0.Lean.Meta.Simp.MethodsRefPointed | Lean.Meta.Tactic.Simp.Types | NonemptyType | true |
DihedralGroup.instIsKleinFourOfNatNat | Mathlib.GroupTheory.SpecificGroups.Dihedral | IsKleinFour (DihedralGroup 2) | true |
Nat.Primes.prodNatEquiv._proof_4 | Mathlib.Data.Nat.Factorization.PrimePow | ∀ (n : { n // IsPrimePow n }),
(fun pk => ⟨↑pk.1 ^ (pk.2 + 1), ⋯⟩) ((fun n => (⟨(↑n).minFac, ⋯⟩, (↑n).factorization (↑n).minFac - 1)) n) = n | false |
_private.Mathlib.Data.Finsupp.BigOperators.0.List.mem_foldr_sup_support_iff._simp_1_1 | Mathlib.Data.Finsupp.BigOperators | ∀ {α : Type u_1} {M : Type u_4} [inst : Zero M] {f : α →₀ M} {a : α}, (a ∈ f.support) = (f a ≠ 0) | false |
MeasureTheory.IsFundamentalDomain.measure_set_eq | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ {G : Type u_1} {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] [inst_2 : MeasurableSpace α] {s t : Set α}
{μ : MeasureTheory.Measure α} [MeasurableConstSMul G α] [MeasureTheory.SMulInvariantMeasure G α μ] [Countable G],
MeasureTheory.IsFundamentalDomain G s μ →
MeasureTheory.IsFundamentalDomain G t μ →
∀ {A : Set α}, MeasurableSet A → (∀ (g : G), (fun x => g • x) ⁻¹' A = A) → μ (A ∩ s) = μ (A ∩ t) | true |
List.rdropWhile_last_not | Mathlib.Data.List.DropRight | ∀ {α : Type u_1} (p : α → Bool) (l : List α) (hl : List.rdropWhile p l ≠ []),
¬p ((List.rdropWhile p l).getLast hl) = true | true |
_private.Lean.LocalContext.0.Lean.LocalDecl.hasValue.match_1 | Lean.LocalContext | (motive : Lean.LocalDecl → Bool → Sort u_1) →
(x : Lean.LocalDecl) →
(x_1 : Bool) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type : Lean.Expr) →
(bi : Lean.BinderInfo) →
(kind : Lean.LocalDeclKind) →
(x : Bool) → motive (Lean.LocalDecl.cdecl index fvarId userName type bi kind) x) →
((index : ℕ) →
(fvarId : Lean.FVarId) →
(userName : Lean.Name) →
(type value : Lean.Expr) →
(nondep : Bool) →
(kind : Lean.LocalDeclKind) →
(allowNondep : Bool) →
motive (Lean.LocalDecl.ldecl index fvarId userName type value nondep kind) allowNondep) →
motive x x_1 | false |
CochainComplex.mappingCone.lift_f_fst_v_assoc | Mathlib.Algebra.Homology.HomotopyCategory.MappingCone | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
{F G : CochainComplex C ℤ} (φ : F ⟶ G) [inst_2 : HomologicalComplex.HasHomotopyCofiber φ] {K : CochainComplex C ℤ}
(α : CochainComplex.HomComplex.Cocycle K F 1) (β : CochainComplex.HomComplex.Cochain K G 0)
(eq : CochainComplex.HomComplex.δ 0 1 β + (↑α).comp (CochainComplex.HomComplex.Cochain.ofHom φ) ⋯ = 0) (p q : ℤ)
(hpq : p + 1 = q) {Z : C} (h : F.X q ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CochainComplex.mappingCone.lift φ α β eq).f p)
(CategoryTheory.CategoryStruct.comp ((↑(CochainComplex.mappingCone.fst φ)).v p q hpq) h) =
CategoryTheory.CategoryStruct.comp ((↑α).v p q hpq) h | true |
Int16.ofInt_int8ToInt | Init.Data.SInt.Lemmas | ∀ (x : Int8), Int16.ofInt x.toInt = x.toInt16 | true |
_private.Mathlib.CategoryTheory.Monoidal.NaturalTransformation.0.CategoryTheory.Adjunction.Equivalence.instIsMonoidalCounit._proof_1 | Mathlib.CategoryTheory.Monoidal.NaturalTransformation | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] [inst_1 : CategoryTheory.MonoidalCategory C]
{D : Type u_2} [inst_2 : CategoryTheory.Category.{u_1, u_2} D] [inst_3 : CategoryTheory.MonoidalCategory D]
(e : C ≌ D) [inst_4 : e.functor.Monoidal] [inst_5 : e.inverse.Monoidal] [e.IsMonoidal],
CategoryTheory.NatTrans.IsMonoidal e.counit | false |
Algebra.TensorProduct.tensorQuotientEquiv | Mathlib.RingTheory.TensorProduct.Quotient | {R : Type u_1} →
(S : Type u_2) →
(T : Type u_3) →
(A : Type u_4) →
[inst : CommRing R] →
[inst_1 : CommRing S] →
[inst_2 : Algebra R S] →
[inst_3 : CommRing T] →
[inst_4 : Algebra R T] →
[inst_5 : CommRing A] →
[inst_6 : Algebra R A] →
[inst_7 : Algebra S A] →
[inst_8 : IsScalarTower R S A] →
(I : Ideal T) →
TensorProduct R A (T ⧸ I) ≃ₐ[S]
TensorProduct R A T ⧸ Ideal.map Algebra.TensorProduct.includeRight I | true |
Std.DTreeMap.Internal.Impl.Const.getEntryLE.congr_simp | Std.Data.DTreeMap.Internal.Model | ∀ {α : Type u} {β : Type v} [inst : Ord α] [inst_1 : Std.TransOrd α] (k k_1 : α) (e_k : k = k_1)
(t t_1 : Std.DTreeMap.Internal.Impl α fun x => β) (e_t : t = t_1) (ho : t.Ordered)
(he : ∃ a ∈ t, (compare a k).isLE = true),
Std.DTreeMap.Internal.Impl.Const.getEntryLE k t ho he = Std.DTreeMap.Internal.Impl.Const.getEntryLE k_1 t_1 ⋯ ⋯ | true |
FirstOrder.Language.Hom.range_eq_top | Mathlib.ModelTheory.Substructures | ∀ {L : FirstOrder.Language} {M : Type w} {N : Type u_1} [inst : L.Structure M] [inst_1 : L.Structure N] {f : L.Hom M N},
f.range = ⊤ ↔ Function.Surjective ⇑f | true |
Multiset.stronglyMeasurable_sum | Mathlib.MeasureTheory.Function.StronglyMeasurable.Basic | ∀ {α : Type u_1} {M : Type u_5} [inst : AddCommMonoid M] [inst_1 : TopologicalSpace M] [ContinuousAdd M]
{m : MeasurableSpace α} (l : Multiset (α → M)),
(∀ f ∈ l, MeasureTheory.StronglyMeasurable f) → MeasureTheory.StronglyMeasurable l.sum | true |
MeasureTheory.Measure.measure_isAddHaarMeasure_eq_smul_of_isOpen | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : AddGroup G] [inst_2 : IsTopologicalAddGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] [LocallyCompactSpace G] (μ' μ : MeasureTheory.Measure G)
[inst_6 : μ.IsAddHaarMeasure] [inst_7 : μ'.IsAddHaarMeasure] {s : Set G},
IsOpen s → μ' s = μ'.addHaarScalarFactor μ • μ s | true |
FiniteInter.finiteInterClosure.below.casesOn | Mathlib.Data.Set.Constructions | ∀ {α : Type u_1} {S : Set (Set α)} {motive : (a : Set α) → FiniteInter.finiteInterClosure S a → Prop}
{motive_1 : {a : Set α} → (t : FiniteInter.finiteInterClosure S a) → FiniteInter.finiteInterClosure.below t → Prop}
{a : Set α} {t : FiniteInter.finiteInterClosure S a} (t_1 : FiniteInter.finiteInterClosure.below t),
(∀ {s : Set α} (a : s ∈ S), motive_1 ⋯ ⋯) →
motive_1 ⋯ ⋯ →
(∀ {s t : Set α} (a : FiniteInter.finiteInterClosure S s) (a_1 : FiniteInter.finiteInterClosure S t)
(ih : FiniteInter.finiteInterClosure.below a) (a_ih : motive s a)
(ih_1 : FiniteInter.finiteInterClosure.below a_1) (a_ih_1 : motive t a_1), motive_1 ⋯ ⋯) →
motive_1 t t_1 | false |
AlgebraicGeometry.Scheme.Cover.mem_pretopology | Mathlib.AlgebraicGeometry.Sites.Pretopology | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {X : AlgebraicGeometry.Scheme}
{𝒰 : AlgebraicGeometry.Scheme.Cover (AlgebraicGeometry.Scheme.precoverage P) X},
CategoryTheory.Presieve.ofArrows 𝒰.X 𝒰.f ∈ (AlgebraicGeometry.Scheme.pretopology P).coverings X | true |
CategoryTheory.Limits.initialUnopOfTerminal._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.IsTerminal | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : Cᵒᵖ} (t : CategoryTheory.Limits.IsTerminal X)
(x : CategoryTheory.Limits.Cocone (CategoryTheory.Functor.empty C))
(x_1 : (CategoryTheory.Limits.asEmptyCocone (Opposite.unop X)).pt ⟶ x.pt),
(∀ (j : CategoryTheory.Discrete PEmpty.{1}),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.Limits.asEmptyCocone (Opposite.unop X)).ι.app j) x_1 =
x.ι.app j) →
x_1 = (t.from (Opposite.op x.pt)).unop | false |
CategoryTheory.IsPullback.exact_shortComplex' | Mathlib.CategoryTheory.Abelian.CommSq | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {X₁ X₂ X₃ X₄ : C}
{t : X₁ ⟶ X₂} {l : X₁ ⟶ X₃} {r : X₂ ⟶ X₄} {b : X₃ ⟶ X₄} (h : CategoryTheory.IsPullback t l r b), ⋯.shortComplex'.Exact | true |
CategoryTheory.IsConnected.of_constant_of_preserves_morphisms | Mathlib.CategoryTheory.IsConnected | ∀ {J : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} J] [Nonempty J],
(∀ {α : Type u₁} (F : J → α), (∀ {j₁ j₂ : J} (x : j₁ ⟶ j₂), F j₁ = F j₂) → ∀ (j j' : J), F j = F j') →
CategoryTheory.IsConnected J | true |
Real.integrable_sinc | Mathlib.MeasureTheory.Function.SpecialFunctions.Sinc | ∀ {μ : MeasureTheory.Measure ℝ} [MeasureTheory.IsFiniteMeasure μ], MeasureTheory.Integrable Real.sinc μ | true |
AlgebraicGeometry.Scheme.Opens.ι | Mathlib.AlgebraicGeometry.Restrict | {X : AlgebraicGeometry.Scheme} → (U : X.Opens) → ↑U ⟶ X | true |
_private.Mathlib.Topology.Sets.Closeds.0.TopologicalSpace.Closeds.isAtom_iff._simp_1_1 | Mathlib.Topology.Sets.Closeds | ∀ {α : Type u_2} [inst : TopologicalSpace α] [T1Space α] {s : TopologicalSpace.Closeds α}, IsAtom s = IsAtom ↑s | false |
CauchyFilter.mem_uniformity' | Mathlib.Topology.UniformSpace.Completion | ∀ {α : Type u} [inst : UniformSpace α] {s : Set (CauchyFilter α × CauchyFilter α)},
s ∈ uniformity (CauchyFilter α) ↔ ∃ t ∈ uniformity α, ∀ (f g : CauchyFilter α), t ∈ ↑f ×ˢ ↑g → (f, g) ∈ s | true |
Lean.Meta.RefinedDiscrTree.format | Mathlib.Lean.Meta.RefinedDiscrTree.Basic | {α : Type} → [Std.ToFormat α] → Lean.Meta.RefinedDiscrTree α → Std.Format | true |
LieModuleHom.toLinearMap | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{M : Type w} →
{N : Type w₁} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : AddCommGroup M] →
[inst_3 : AddCommGroup N] →
[inst_4 : Module R M] →
[inst_5 : Module R N] →
[inst_6 : LieRingModule L M] → [inst_7 : LieRingModule L N] → (M →ₗ⁅R,L⁆ N) → M →ₗ[R] N | true |
_private.Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro.0.groupCohomology.linearYonedaObjResProjectiveResolutionIso._simp_1 | Mathlib.RepresentationTheory.Homological.GroupCohomology.Shapiro | ∀ {R : Type u} [inst : Ring R] {M N O : Type v} [inst_1 : AddCommGroup M] [inst_2 : AddCommGroup N]
[inst_3 : AddCommGroup O] [inst_4 : Module R M] [inst_5 : Module R N] [inst_6 : Module R O] (f : M →ₗ[R] N)
(g : N →ₗ[R] O), CategoryTheory.CategoryStruct.comp (ModuleCat.ofHom f) (ModuleCat.ofHom g) = ModuleCat.ofHom (g ∘ₗ f) | false |
Real.instAddMonoid | Mathlib.Data.Real.Basic | AddMonoid ℝ | true |
_private.Init.Data.Range.Polymorphic.Char.0.Char.instPreservesLEFinNumCodePointsMap | Init.Data.Range.Polymorphic.Char | Char.map✝.PreservesLE | true |
Algebra.trace.eq_1 | Mathlib.RingTheory.Trace.Defs | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S],
Algebra.trace R S = LinearMap.trace R S ∘ₗ (Algebra.lmul R S).toLinearMap | true |
Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat.elim | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | {motive_7 : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof) →
t.ctorIdx = 1 →
((e thm : Lean.Expr) →
(d : ℕ) → (a : Int.Linear.Expr) → motive_7 (Lean.Meta.Grind.Arith.Cutsat.DvdCnstrProof.coreOfNat e thm d a)) →
motive_7 t | false |
_private.Mathlib.RingTheory.Adjoin.FG.0.Subalgebra.FG.map.match_1_1 | Mathlib.RingTheory.Adjoin.FG | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
{S : Subalgebra R A} (motive : S.FG → Prop) (hs : S.FG),
(∀ (s : Finset A) (hs : Algebra.adjoin R ↑s = S), motive ⋯) → motive hs | false |
_private.Lean.Meta.SynthInstance.0.Lean.Meta.SynthInstance.tryAnswer.match_1 | Lean.Meta.SynthInstance | (motive : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr → Sort u_1) →
(__discr : Array Lean.Expr × Array Lean.BinderInfo × Lean.Expr) →
((fst : Array Lean.Expr) → (fst_1 : Array Lean.BinderInfo) → (val : Lean.Expr) → motive (fst, fst_1, val)) →
motive __discr | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.