name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
LipschitzWith.lipschitzOnWith | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β}
{s : Set α}, LipschitzWith K f → LipschitzOnWith K f s | true |
Multiset.countP_le_of_le | Mathlib.Data.Multiset.Count | ∀ {α : Type u_1} (p : α → Prop) [inst : DecidablePred p] {s t : Multiset α},
s ≤ t → Multiset.countP p s ≤ Multiset.countP p t | true |
Cardinal.instCommMonoidWithZero._proof_5 | Mathlib.SetTheory.Cardinal.Order | ∀ (n : ℕ) (x : Cardinal.{u_1}), Semiring.npow (n + 1) x = Semiring.npow n x * x | false |
CategoryTheory.Functor.OplaxMonoidal.id._proof_2 | Mathlib.CategoryTheory.Monoidal.Functor | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.MonoidalCategory C] {X Y : C}
(f : X ⟶ Y) (X' : C),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.CategoryStruct.id
((CategoryTheory.Functor.id C).obj (CategoryTheory.MonoidalCategoryStruct.tensorObj X X')))
... | false |
iSup_eq_bot | Mathlib.Order.CompleteLattice.Basic | ∀ {α : Type u_1} {ι : Sort u_4} [inst : CompleteLattice α] {s : ι → α}, iSup s = ⊥ ↔ ∀ (i : ι), s i = ⊥ | true |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.ExBase.evalNatCast.match_3 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
(sα : Q(CommSemiring «$α»)) →
{a : Q(ℕ)} →
(motive : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a») → Sort u_1) →
(__discr : Mathlib.Tactic.Ring.Result (Mathlib.Tactic.Ring.ExSum sα) q(↑«$a»)) →
((expr : Q(«$α»)) →
... | false |
List.dropLast_eq_eraseIdx | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {i : ℕ}, i + 1 = xs.length → xs.dropLast = xs.eraseIdx i | true |
Lean.Parser.CacheableParserContext.noConfusion | Lean.Parser.Types | {P : Sort u} →
{t t' : Lean.Parser.CacheableParserContext} → t = t' → Lean.Parser.CacheableParserContext.noConfusionType P t t' | false |
_private.Mathlib.Topology.EMetricSpace.BoundedVariation.0.eVariationOn.add_le_union._proof_1_3 | Mathlib.Topology.EMetricSpace.BoundedVariation | ∀ (n m : ℕ), Finset.range n ∪ Finset.Ico (n + 1) (n + 1 + m) ⊆ Finset.range (n + 1 + m) | false |
_private.Lean.Environment.0.Lean.AsyncConsts.normalizedTrie | Lean.Environment | Lean.AsyncConsts✝ → Lean.NameTrie Lean.AsyncConst✝ | true |
Int.mul_fmod_left | Init.Data.Int.DivMod.Lemmas | ∀ (a b : ℤ), (a * b).fmod b = 0 | true |
PNat.instMetricSpace._proof_16 | Mathlib.Topology.Instances.PNat | Filter.Tendsto Prod.swap PNat.instMetricSpace._aux_14 PNat.instMetricSpace._aux_14 | false |
CategoryTheory.ShortComplex.cyclesMapIso'._proof_2 | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (e : S₁ ≅ S₂) (h₁ : S₁.LeftHomologyData) (h₂ : S₂.LeftHomologyData),
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.cyclesMap' e.inv h₂ h₁)
... | false |
_private.Mathlib.Tactic.CategoryTheory.Coherence.Normalize.0.Mathlib.Tactic.BicategoryLike.evalWhiskerRightAux.match_1 | Mathlib.Tactic.CategoryTheory.Coherence.Normalize | (motive : Mathlib.Tactic.BicategoryLike.HorizontalComp → Mathlib.Tactic.BicategoryLike.Atom₁ → Sort u_1) →
(x : Mathlib.Tactic.BicategoryLike.HorizontalComp) →
(x_1 : Mathlib.Tactic.BicategoryLike.Atom₁) →
((η : Mathlib.Tactic.BicategoryLike.WhiskerRight) →
(f : Mathlib.Tactic.BicategoryLike.Atom₁... | false |
Array.filter_replicate_of_neg | Init.Data.Array.Lemmas | ∀ {stop n : ℕ} {α : Type u_1} {p : α → Bool} {a : α},
stop = n → ¬p a = true → Array.filter p (Array.replicate n a) 0 stop = #[] | true |
LieEquiv.invFun | Mathlib.Algebra.Lie.Basic | {R : Type u} →
{L : Type v} →
{L' : Type w} →
[inst : CommRing R] →
[inst_1 : LieRing L] →
[inst_2 : LieAlgebra R L] → [inst_3 : LieRing L'] → [inst_4 : LieAlgebra R L'] → (L ≃ₗ⁅R⁆ L') → L' → L | true |
UniformContinuous.sup_compacts | Mathlib.Topology.UniformSpace.Closeds | ∀ {α : Type u_1} {β : Type u_2} [inst : UniformSpace α] [inst_1 : UniformSpace β]
{f g : α → TopologicalSpace.Compacts β},
UniformContinuous f → UniformContinuous g → UniformContinuous fun x => f x ⊔ g x | true |
subset_of_subset_of_eq | Mathlib.Order.RelClasses | ∀ {α : Type u} [inst : HasSubset α] {a b c : α}, a ⊆ b → b = c → a ⊆ c | true |
toIcoDiv_add_intCast_mul | Mathlib.Algebra.Order.ToIntervalMod | ∀ {R : Type u_1} [inst : NonAssocRing R] [inst_1 : LinearOrder R] [inst_2 : IsOrderedAddMonoid R]
[inst_3 : Archimedean R] {p : R} (hp : 0 < p) (a b : R) (m : ℤ), toIcoDiv hp a (b + ↑m * p) = toIcoDiv hp a b + m | true |
Set.biInter_subset_biUnion | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {β : Type u_2} {s : Set α}, s.Nonempty → ∀ {t : α → Set β}, ⋂ x ∈ s, t x ⊆ ⋃ x ∈ s, t x | true |
AbstractCompletion.mapEquiv._proof_3 | Mathlib.Topology.UniformSpace.AbstractCompletion | ∀ {α : Type u_3} [inst : UniformSpace α] (pkg : AbstractCompletion.{u_1, u_3} α) {β : Type u_4}
[inst_1 : UniformSpace β] (pkg' : AbstractCompletion.{u_2, u_4} β) (e : α ≃ᵤ β),
Function.LeftInverse (pkg'.map pkg ⇑e.symm) (pkg.map pkg' ⇑e) | false |
SymAlg.addMonoid._proof_1 | Mathlib.Algebra.Symmetrized | ∀ {α : Type u_1} [inst : AddMonoid α], SymAlg.unsym 0 = 0 | false |
CategoryTheory.Coyoneda.colimitCocone_pt | Mathlib.CategoryTheory.Limits.Yoneda | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (X : Cᵒᵖ),
(CategoryTheory.Coyoneda.colimitCocone X).pt = PUnit.{v + 1} | true |
Std.Tactic.BVDecide.BVExpr.bitblast.denote_blastNeg | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Lemmas.Operations.Neg | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {w : ℕ} (aig : Std.Sat.AIG α) (value : BitVec w)
(target : aig.RefVec w) (assign : α → Bool),
(∀ (idx : ℕ) (hidx : idx < w), ⟦assign, { aig := aig, ref := target.get idx hidx }⟧ = value.getLsbD idx) →
∀ (idx : ℕ) (hidx : idx < w),
⟦assign,
... | true |
Int8.neg_neg | Init.Data.SInt.Lemmas | ∀ {a : Int8}, - -a = a | true |
_private.Mathlib.Util.CompileInductive.0.Float.mk_eq | Mathlib.Util.CompileInductive | Float.mk = Float.mkImpl✝ | true |
Std.Do.Spec.forIn'_rii._proof_3 | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} [inst : Std.PRange.Least? α] [inst_1 : Std.PRange.UpwardEnumerable α]
[inst_2 : Std.Rxi.IsAlwaysFinite α] [inst_3 : Std.PRange.LawfulUpwardEnumerable α] {xs : Std.Rii α} (pref : List α)
(cur : α) (suff : List α), xs.toList = pref ++ cur :: suff → pref ++ [cur] ++ suff = xs.toList | false |
_private.Mathlib.FieldTheory.Normal.Closure.0.isNormalClosure_normalClosure.match_1 | Mathlib.FieldTheory.Normal.Closure | ∀ (F : Type u_3) (K : Type u_2) (L : Type u_1) [inst : Field F] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra F K] [inst_4 : Algebra F L] (motive : Nonempty (K →ₐ[F] L) → Prop) (ne : Nonempty (K →ₐ[F] L)),
(∀ (φ : K →ₐ[F] L), motive ⋯) → motive ne | false |
LieDerivation.instLieRing._proof_1 | Mathlib.Algebra.Lie.Derivation.Basic | ∀ {R : Type u_2} {L : Type u_1} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L]
(d e f : LieDerivation R L L), ⁅d + e, f⁆ = ⁅d, f⁆ + ⁅e, f⁆ | false |
Turing.PartrecToTM2.Λ'.rec | Mathlib.Computability.TuringMachine.ToPartrec | {motive : Turing.PartrecToTM2.Λ' → Sort u} →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k₁ k₂ : Turing.PartrecToTM2.K') →
(q : Turing.PartrecToTM2.Λ') → motive q → motive (Turing.PartrecToTM2.Λ'.move p k₁ k₂ q)) →
((p : Turing.PartrecToTM2.Γ' → Bool) →
(k : Turing.PartrecToTM2.K') →
(... | false |
WithZero.le_log_of_exp_le | Mathlib.Algebra.Order.GroupWithZero.Canonical | ∀ {G : Type u_3} [inst : Preorder G] {a : G} [inst_1 : AddGroup G] {x : WithZero (Multiplicative G)},
WithZero.exp a ≤ x → a ≤ x.log | true |
Rep.FiniteCyclicGroup.groupHomologyIsoOdd._proof_1 | Mathlib.RepresentationTheory.Homological.GroupHomology.FiniteCyclic | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : CommGroup G] [inst_2 : Fintype G] (A : Rep.{u_1, u_1, u_1} k G)
(g : G), (Rep.FiniteCyclicGroup.normHomCompSub A g).HasHomology | false |
EReal.neTopBotEquivReal._proof_7 | Mathlib.Data.EReal.Basic | ∀ (x : ℝ), (fun x => (↑x).toReal) ((fun x => ⟨↑x, ⋯⟩) x) = x | false |
LinearMap.tensorKerBil._proof_6 | Mathlib.RingTheory.Flat.Equalizer | ∀ {R : Type u_1} (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Algebra R S] (M : Type u_3)
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : Module S M] [inst_6 : IsScalarTower R S M] {N : Type u_4}
{P : Type u_5} [inst_7 : AddCommGroup N] [inst_8 : AddCommGroup P] [inst_9 : Module R N]... | false |
_private.Mathlib.Tactic.FBinop.0.FBinopElab.applyCoe | Mathlib.Tactic.FBinop | FBinopElab.Tree✝ → FBinopElab.SRec → Lean.Elab.TermElabM FBinopElab.Tree✝¹ | true |
max_le_max_left | Mathlib.Order.MinMax | ∀ {α : Type u} [inst : LinearOrder α] {a b : α} (c : α), a ≤ b → max c a ≤ max c b | true |
Mathlib.Meta.FunProp.FunctionData.casesOn | Mathlib.Tactic.FunProp.FunctionData | {motive : Mathlib.Meta.FunProp.FunctionData → Sort u} →
(t : Mathlib.Meta.FunProp.FunctionData) →
((lctx : Lean.LocalContext) →
(insts : Lean.LocalInstances) →
(fn : Lean.Expr) →
(args : Array Mathlib.Meta.FunProp.Mor.Arg) →
(mainVar : Lean.Expr) →
(main... | false |
FourierSMul.mk._flat_ctor | Mathlib.Analysis.Fourier.Notation | ∀ {R : Type u_5} {E : Type u_6} {F : outParam (Type u_7)} [inst : SMul R E] [inst_1 : SMul R F]
[inst_2 : FourierTransform E F],
(∀ (r : R) (f : E), FourierTransform.fourier (r • f) = r • FourierTransform.fourier f) → FourierSMul R E F | false |
Subfield.relfinrank_map_map | Mathlib.FieldTheory.Relrank | ∀ {E : Type v} [inst : Field E] {L : Type w} [inst_1 : Field L] (A B : Subfield E) (f : E →+* L),
(Subfield.map f A).relfinrank (Subfield.map f B) = A.relfinrank B | true |
SkewMonoidAlgebra.addHom_ext_iff | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddCommMonoid k] {M : Type u_3} [inst_1 : AddZeroClass M]
{f g : SkewMonoidAlgebra k G →+ M},
f = g ↔ ∀ (a : G) (b : k), f (SkewMonoidAlgebra.single a b) = g (SkewMonoidAlgebra.single a b) | true |
Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit.sizeOf_spec | Lean.Meta.Tactic.Grind.Arith.Cutsat.Types | ∀ (c₁ : Lean.Meta.Grind.Arith.Cutsat.DiseqCnstr) (decVar : Lean.FVarId) (h : Lean.Meta.Grind.Arith.Cutsat.UnsatProof)
(decVars : Array Lean.FVarId),
sizeOf (Lean.Meta.Grind.Arith.Cutsat.LeCnstrProof.ofDiseqSplit c₁ decVar h decVars) =
1 + sizeOf c₁ + sizeOf decVar + sizeOf h + sizeOf decVars | true |
Std.Internal.List.getValueCast_modifyKey._proof_2 | Std.Data.Internal.List.Associative | ∀ {α : Type u_1} {β : α → Type u_2} [inst : BEq α] [inst_1 : LawfulBEq α] {k k' : α} {f : β k → β k}
(l : List ((a : α) × β a)),
Std.Internal.List.containsKey k' (Std.Internal.List.modifyKey k f l) = true →
Std.Internal.List.containsKey k' l = true | false |
Lean.Meta.Grind.Arith.CommRing.State.noConfusionType | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Sort u → Lean.Meta.Grind.Arith.CommRing.State → Lean.Meta.Grind.Arith.CommRing.State → Sort u | false |
_private.Mathlib.Probability.Process.Stopping.0.MeasureTheory.measurable_stoppedValue._simp_1_7 | Mathlib.Probability.Process.Stopping | ∀ {α : Type u_1} {a b : α} [inst : LE α], (↑b ≤ ↑a) = (b ≤ a) | false |
ZMod.val.match_1 | Mathlib.Data.ZMod.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x | false |
Finset.mul.eq_1 | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : Mul α], Finset.mul = { mul := Finset.image₂ fun x1 x2 => x1 * x2 } | true |
NonemptyInterval.subtractionCommMonoid._proof_10 | Mathlib.Algebra.Order.Interval.Basic | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : PartialOrder α] [IsOrderedAddMonoid α],
CovariantClass α α (Function.swap fun x1 x2 => x1 + x2) fun x1 x2 => x1 ≤ x2 | false |
_private.Init.Data.Option.Lemmas.0.Option.merge.match_1.eq_4 | Init.Data.Option.Lemmas | ∀ {α : Type u_1} (motive : Option α → Option α → Sort u_2) (x y : α) (h_1 : Unit → motive none none)
(h_2 : (x : α) → motive (some x) none) (h_3 : (y : α) → motive none (some y))
(h_4 : (x y : α) → motive (some x) (some y)),
(match some x, some y with
| none, none => h_1 ()
| some x, none => h_2 x
| n... | true |
CategoryTheory.Limits.isLimitConeOfCoconeUnop._proof_1 | Mathlib.CategoryTheory.Limits.Opposites | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {J : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} J] (F : CategoryTheory.Functor Jᵒᵖ Cᵒᵖ)
{c : CategoryTheory.Limits.Cocone F.unop} (hc : CategoryTheory.Limits.IsColimit c) (s : CategoryTheory.Limits.Cone F)
(j : Jᵒᵖ),
(CategoryTheory.Cate... | false |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.Const.getKey!_insertManyIfNewUnit_list_of_mem._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) | false |
PythagoreanTriple.mul_isClassified | Mathlib.NumberTheory.PythagoreanTriples | ∀ {x y z : ℤ} (h : PythagoreanTriple x y z) (k : ℤ), h.IsClassified → ⋯.IsClassified | true |
Std.Packages.LinearPreorderOfOrdArgs.decidableLT._autoParam | Init.Data.Order.PackageFactories | Lean.Syntax | false |
_private.Mathlib.Tactic.TFAE.0.Mathlib.Tactic.TFAE.getTFAEList.match_1 | Mathlib.Tactic.TFAE | (motive : Lean.Expr → Sort u_1) →
(__discr : Lean.Expr) →
((tfae : Lean.Expr) → (l : Q(List Prop)) → motive (tfae.app l)) → ((x : Lean.Expr) → motive x) → motive __discr | false |
ULift.leftCancelSemigroup.eq_1 | Mathlib.Algebra.Group.ULift | ∀ {α : Type u} [inst : LeftCancelSemigroup α],
ULift.leftCancelSemigroup = Function.Injective.leftCancelSemigroup ⇑Equiv.ulift ⋯ ⋯ | true |
_private.Mathlib.MeasureTheory.Function.LpSeminorm.SMul.0.MeasureTheory.eLpNormEssSup_const_smul_le._simp_1_1 | Mathlib.MeasureTheory.Function.LpSeminorm.SMul | ∀ {α : Type u_1} {β : Type u_2} [inst : SeminormedAddGroup α] [inst_1 : SeminormedAddGroup β]
[inst_2 : SMulZeroClass α β] [IsBoundedSMul α β] (r : α) (x : β), (‖r • x‖₊ ≤ ‖r‖₊ * ‖x‖₊) = True | false |
_private.Mathlib.NumberTheory.ModularForms.CongruenceSubgroups.0.CongruenceSubgroup.conjGL_coe._simp_1_4 | Mathlib.NumberTheory.ModularForms.CongruenceSubgroups | ∀ {α : Type u_1} {G : Type u_2} [inst : Group G] [inst_1 : Group α] [inst_2 : MulDistribMulAction α G] {a : α}
{S : Subgroup G} {x : G}, (x ∈ a⁻¹ • S) = (a • x ∈ S) | false |
le_imp_le_of_le_of_le | Mathlib.Order.Basic | ∀ {α : Type u_2} [inst : Preorder α] {a b c d : α}, c ≤ a → b ≤ d → a ≤ b → c ≤ d | true |
_private.Mathlib.Lean.Meta.RefinedDiscrTree.Encode.0.Lean.Meta.RefinedDiscrTree.getStackEntries.isIgnoredArg | Mathlib.Lean.Meta.RefinedDiscrTree.Encode | Lean.Expr → Lean.Expr → Lean.BinderInfo → Lean.MetaM Bool | true |
CategoryTheory.Limits.HasPushout | Mathlib.CategoryTheory.Limits.Shapes.Pullback.HasPullback | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → {X Y Z : C} → (X ⟶ Y) → (X ⟶ Z) → Prop | true |
AddCommGrpCat.addCommGroupObj._aux_1 | Mathlib.Algebra.Category.Grp.Limits | {J : Type u_3} →
[inst : CategoryTheory.Category.{u_2, u_3} J] →
(F : CategoryTheory.Functor J AddCommGrpCat) →
(j : J) → AddCommGroup ((F.comp (CategoryTheory.forget AddCommGrpCat)).obj j) | false |
Algebra.TensorProduct.algebraMap_def | Mathlib.RingTheory.TensorProduct.Basic | ∀ {R : Type uR} {S : Type uS} {A : Type uA} {B : Type uB} [inst : CommSemiring R] [inst_1 : Semiring A]
[inst_2 : Algebra R A] [inst_3 : Semiring B] [inst_4 : Algebra R B] [inst_5 : CommSemiring S] [inst_6 : Algebra S A]
[inst_7 : SMulCommClass R S A],
algebraMap S (TensorProduct R A B) = Algebra.TensorProduct.in... | true |
CategoryTheory.Pretopology.gi | Mathlib.CategoryTheory.Sites.Pretopology | (C : Type u) →
[inst : CategoryTheory.Category.{v, u} C] →
[inst_1 : CategoryTheory.Limits.HasPullbacks C] →
GaloisInsertion CategoryTheory.Pretopology.toGrothendieck CategoryTheory.GrothendieckTopology.toPretopology | true |
Lean.RBTree.contains | Lean.Data.RBTree | {α : Type u} → {cmp : α → α → Ordering} → Lean.RBTree α cmp → α → Bool | true |
CategoryTheory.Limits.instHasCokernelFromSubtype | Mathlib.CategoryTheory.Limits.Shapes.Biproducts | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] {K : Type}
[inst_2 : Finite K] [inst_3 : CategoryTheory.Limits.HasFiniteBiproducts C] (f : K → C) (p : K → Prop),
CategoryTheory.Limits.HasCokernel (CategoryTheory.Limits.biproduct.fromSubtype f p) | true |
Equiv.ofRightInverseOfCardLE_apply | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {β : Type u_2} [inst : Fintype α] [inst_1 : Fintype β] (hαβ : Fintype.card α ≤ Fintype.card β)
(f : α → β) (g : β → α) (h : Function.RightInverse g f) (a : α), (Equiv.ofRightInverseOfCardLE hαβ f g h) a = f a | true |
NonUnitalSubalgebra.instModule._proof_1 | Mathlib.Algebra.Algebra.NonUnitalSubalgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A],
IsScalarTower R R A | false |
List.countP_cons_of_neg | Init.Data.List.Count | ∀ {α : Type u_1} {p : α → Bool} {a : α} {l : List α}, ¬p a = true → List.countP p (a :: l) = List.countP p l | true |
ContinuousLinearMap.coe_smul._simp_1 | Mathlib.Topology.Algebra.Module.LinearMap | ∀ {R₁ : Type u_1} {R₂ : Type u_2} [inst : Semiring R₁] [inst_1 : Semiring R₂] {σ₁₂ : R₁ →+* R₂} {M₁ : Type u_4}
[inst_2 : TopologicalSpace M₁] [inst_3 : AddCommMonoid M₁] {M₂ : Type u_6} [inst_4 : TopologicalSpace M₂]
[inst_5 : AddCommMonoid M₂] [inst_6 : Module R₁ M₁] [inst_7 : Module R₂ M₂] {S₂ : Type u_9}
[ins... | false |
_private.Mathlib.Topology.UniformSpace.Cauchy.0.isComplete_iff_ultrafilter'._simp_1_1 | Mathlib.Topology.UniformSpace.Cauchy | ∀ {α : Type u} {s : Set α} {f : Filter α}, (f ≤ Filter.principal s) = (s ∈ f) | false |
Std.TreeMap.maxKey_le_maxKey_insert | Std.Data.TreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.TreeMap α β cmp} [inst : Std.TransCmp cmp] {k : α} {v : β}
{he : t.isEmpty = false}, (cmp (t.maxKey he) ((t.insert k v).maxKey ⋯)).isLE = true | true |
Aesop.RuleBuilderOptions.mk | Aesop.Builder.Basic | Option (Array Lean.Name) →
Option Aesop.IndexingMode →
Option (Array Aesop.CasesPattern) →
Option Lean.Term →
Option Lean.Meta.TransparencyMode → Option Lean.Meta.TransparencyMode → Aesop.RuleBuilderOptions | true |
MeasureTheory.setLIntegral_congr_fun | Mathlib.MeasureTheory.Integral.Lebesgue.Basic | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {f g : α → ENNReal} {s : Set α},
MeasurableSet s → Set.EqOn f g s → ∫⁻ (x : α) in s, f x ∂μ = ∫⁻ (x : α) in s, g x ∂μ | true |
_private.Lean.Meta.Tactic.Simp.SimpTheorems.0.Lean.Meta.preprocess | Lean.Meta.Tactic.Simp.SimpTheorems | Lean.Expr → Lean.Expr → Bool → Bool → Lean.MetaM (List (Lean.Expr × Lean.Expr)) | true |
OrderedFinpartition.compAlongOrderedFinpartitionL_apply | Mathlib.Analysis.Calculus.ContDiff.FaaDiBruno | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_3} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {G : Type u_4}
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] {n : ℕ} (c : OrderedFinpartition n)
... | true |
AddMonoidAlgebra.supportedEquivFinsupp._proof_11 | Mathlib.Algebra.MonoidAlgebra.Module | ∀ {R : Type u_3} {M : Type u_1} {S : Type u_2} [inst : Semiring R] [inst_1 : Semiring S] [inst_2 : Module R S]
(s : Set M) (x : ↥(Finsupp.supported S R s)),
⟨(↑⟨AddMonoidAlgebra.ofCoeff ↑x, ⋯⟩).coeff, ⋯⟩ = ⟨(↑⟨AddMonoidAlgebra.ofCoeff ↑x, ⋯⟩).coeff, ⋯⟩ | false |
isLocalMax_of_deriv | Mathlib.Analysis.Calculus.DerivativeTest | ∀ {f : ℝ → ℝ} {b : ℝ},
ContinuousAt f b →
(∀ᶠ (x : ℝ) in nhdsWithin b {b}ᶜ, DifferentiableAt ℝ f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Iio b), 0 ≤ deriv f x) →
(∀ᶠ (x : ℝ) in nhdsWithin b (Set.Ioi b), deriv f x ≤ 0) → IsLocalMax f b | true |
BoundedContinuousFunction.instAddZeroClass | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : AddZeroClass R] → [BoundedAdd R] → [ContinuousAdd R] → AddZeroClass (BoundedContinuousFunction α R) | true |
instPartialOrderEReal._proof_8 | Mathlib.Data.EReal.Basic | ∀ (a b : EReal), a ≤ b → b ≤ a → a = b | false |
_private.Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic.0.RootPairing.GeckConstruction.ωConj._simp_4 | Mathlib.LinearAlgebra.RootSystem.GeckConstruction.Basic | ∀ {G : Type u_1} [inst : Semigroup G] (a b c : G), a * (b * c) = a * b * c | false |
LinearEquiv.finTwoArrow_apply | Mathlib.LinearAlgebra.Pi | ∀ (R : Type u) (M : Type v) [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M],
⇑(LinearEquiv.finTwoArrow R M) = fun f => (f 0, f 1) | true |
NNRat.cast_lt_natCast._simp_1 | Mathlib.Data.Rat.Cast.Order | ∀ {K : Type u_5} [inst : Semifield K] [inst_1 : LinearOrder K] [IsStrictOrderedRing K] {m : ℚ≥0} {n : ℕ},
(↑m < ↑n) = (m < ↑n) | false |
MulChar.ofUnitHom.eq_1 | Mathlib.NumberTheory.MulChar.Basic | ∀ {R : Type u_1} [inst : CommMonoid R] {R' : Type u_2} [inst_1 : CommMonoidWithZero R'] (f : Rˣ →* R'ˣ),
MulChar.ofUnitHom f =
{ toFun := fun x => if hx : IsUnit x then ↑(f hx.unit) else 0, map_one' := ⋯, map_mul' := ⋯, map_nonunit' := ⋯ } | true |
CStarMatrix.map_map | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_5} {B : Type u_6} {C : Type u_7} {M : Matrix m n A} {f : A → B} {g : B → C},
(M.map f).map g = M.map (g ∘ f) | true |
AddLocalization.le._proof_1 | Mathlib.GroupTheory.MonoidLocalization.Order | ∀ {α : Type u_1} [inst : AddCommMonoid α] [inst_1 : PartialOrder α] [IsOrderedCancelAddMonoid α] {s : AddSubmonoid α}
{a₁ b₁ : α} {a₂ b₂ : ↥s} {c₁ d₁ : α} {c₂ d₂ : ↥s},
(AddLocalization.r s) (a₁, a₂) (b₁, b₂) →
(AddLocalization.r s) (c₁, c₂) (d₁, d₂) → (↑c₂ + a₁ ≤ ↑a₂ + c₁) = (↑d₂ + b₁ ≤ ↑b₂ + d₁) | false |
_private.Mathlib.Tactic.Simproc.Factors.0.Nat.primeFactorsList_ofNat.match_3 | Mathlib.Tactic.Simproc.Factors | (motive :
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e) → Sort u_1) →
(u : Lean.Level) →
(α : Q(Sort u)) →
(e : Q(«$α»)) →
(__alt __alt_1 : Lean.Meta.SimpM (Lean.Meta.Simp.StepQ e))... | false |
Std.ExtTreeMap.contains_eq_isSome_getElem? | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp] {a : α},
t.contains a = t[a]?.isSome | true |
OrderAddMonoidHom.comp | Mathlib.Algebra.Order.Hom.Monoid | {α : Type u_2} →
{β : Type u_3} →
{γ : Type u_4} →
[inst : Preorder α] →
[inst_1 : Preorder β] →
[inst_2 : Preorder γ] →
[inst_3 : AddZeroClass α] →
[inst_4 : AddZeroClass β] → [inst_5 : AddZeroClass γ] → (β →+o γ) → (α →+o β) → α →+o γ | true |
Int8.toInt_ofNat' | Init.Data.SInt.Lemmas | ∀ {n : ℕ}, (Int8.ofNat n).toInt = (↑n).bmod Int8.size | true |
Unitization.instCommCStarAlgebra._proof_12 | Mathlib.Analysis.CStarAlgebra.Unitization | ∀ {A : Type u_1} [inst : NonUnitalCommCStarAlgebra A], CStarRing (Unitization ℂ A) | false |
AugmentedSimplexCategory.equivAugmentedCosimplicialObject_functor_map_left | Mathlib.AlgebraicTopology.SimplexCategory.Augmented.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C]
{X Y : CategoryTheory.Functor (CategoryTheory.WithInitial SimplexCategory) C} (η : X ⟶ Y),
(AugmentedSimplexCategory.equivAugmentedCosimplicialObject.functor.map η).left = η.app CategoryTheory.WithInitial.star | true |
OrderHom.coe_antisymmetrization | Mathlib.Order.Antisymmetrization | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α →o β),
⇑f.antisymmetrization = Quotient.map' ⇑f ⋯ | true |
Lean.ModuleSetup.mk.sizeOf_spec | Lean.Setup | ∀ (name : Lean.Name) (package? : Option Lean.PkgId) (isModule : Bool) (imports? : Option (Array Lean.Import))
(importArts : Lean.NameMap Lean.ImportArtifacts) (dynlibs plugins : Array System.FilePath)
(options : Lean.LeanOptions),
sizeOf
{ name := name, package? := package?, isModule := isModule, imports? :... | true |
isCancelMul_iff | Mathlib.Algebra.Group.Defs | ∀ (G : Type u) [inst : Mul G], IsCancelMul G ↔ IsLeftCancelMul G ∧ IsRightCancelMul G | true |
_private.Mathlib.RingTheory.Kaehler.Basic.0.KaehlerDifferential.kerTotal_mkQ_single_mul._simp_1_1 | Mathlib.RingTheory.Kaehler.Basic | ∀ {α : Type u_1} {M : Type u_5} {R : Type u_11} [inst : Zero M] [inst_1 : SMulZeroClass R M] (c : R) (a : α) (b : M),
(fun₀ | a => c • b) = c • fun₀ | a => b | false |
_private.Mathlib.GroupTheory.CoprodI.0.Monoid.CoprodI.Word.mem_rcons_iff._proof_1_13 | Mathlib.GroupTheory.CoprodI | ∀ {ι : Type u_1} {M : ι → Type u_2} [inst : (i : ι) → Monoid (M i)] [inst_1 : (i : ι) → DecidableEq (M i)] {i j : ι}
(p : Monoid.CoprodI.Word.Pair M i) (m : M j),
⟨j, m⟩ ∈
(if h : p.head = 1 then p.tail
else { toList := ⟨i, p.head⟩ :: p.tail.toList, ne_one := ⋯, chain_ne := ⋯ }).toList ↔
⟨j, m⟩ ∈ ... | false |
CategoryTheory.ShortComplex.SnakeInput.functorP_obj | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex.SnakeInput C), CategoryTheory.ShortComplex.SnakeInput.functorP.obj S = S.P | true |
HNNExtension.NormalWord.noConfusion | Mathlib.GroupTheory.HNNExtension | {P : Sort u} →
{G : Type u_1} →
{inst : Group G} →
{A B : Subgroup G} →
{d : HNNExtension.NormalWord.TransversalPair G A B} →
{t : HNNExtension.NormalWord d} →
{G' : Type u_1} →
{inst' : Group G'} →
{A' B' : Subgroup G'} →
{d' : H... | false |
CategoryTheory.Limits.BinaryBicone.instIsSplitEpiSnd | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{P Q : C} (c : CategoryTheory.Limits.BinaryBicone P Q), CategoryTheory.IsSplitEpi c.snd | true |
CategoryTheory.Functor.CorepresentableBy.isoCoreprX | Mathlib.CategoryTheory.Yoneda | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{F : CategoryTheory.Functor C (Type v)} →
[hF : F.IsCorepresentable] → {Y : C} → F.CorepresentableBy Y → (Y ≅ F.coreprX) | true |
Matrix.toLinOfInv._proof_1 | Mathlib.LinearAlgebra.Matrix.ToLin | ∀ {R : Type u_3} [inst : CommSemiring R] {m : Type u_4} {n : Type u_5} [inst_1 : Fintype n] [inst_2 : DecidableEq n]
{M₁ : Type u_1} {M₂ : Type u_2} [inst_3 : AddCommMonoid M₁] [inst_4 : AddCommMonoid M₂] [inst_5 : Module R M₁]
[inst_6 : Module R M₂] (v₁ : Module.Basis n R M₁) (v₂ : Module.Basis m R M₂) [inst_7 : F... | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.