name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
Std.DHashMap.Internal.Raw₀.Const.get_modify | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {β : Type v} [inst_2 : EquivBEq α] [inst_3 : LawfulHashable α]
(m : Std.DHashMap.Internal.Raw₀ α fun x => β) (h : (↑m).WF) {k k' : α} {f : β → β}
(hc : (Std.DHashMap.Internal.Raw₀.Const.modify m k f).contains k' = true),
Std.DHashMap.Internal.Raw₀.Const.get (Std... | true |
basis_toMatrix_basisFun_mul | Mathlib.LinearAlgebra.Matrix.Basis | ∀ {ι : Type u_1} {R : Type u_5} [inst : CommSemiring R] [inst_1 : Fintype ι] (b : Module.Basis ι R (ι → R))
(A : Matrix ι ι R), b.toMatrix ⇑(Pi.basisFun R ι) * A = Matrix.of fun i j => (b.repr (A.col j)) i | true |
CategoryTheory.Limits.ReflectsCofilteredLimitsOfSize | Mathlib.CategoryTheory.Limits.Preserves.Filtered | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} → [inst_1 : CategoryTheory.Category.{v₂, u₂} D] → CategoryTheory.Functor C D → Prop | true |
_private.Init.Data.Array.Range.0.Array.mem_range'_1._simp_1_1 | Init.Data.Array.Range | ∀ {s step m n : ℕ}, (m ∈ Array.range' s n step) = ∃ i < n, m = s + step * i | false |
SemiconjBy.op | Mathlib.Algebra.Group.Opposite | ∀ {α : Type u_1} [inst : Mul α] {a x y : α},
SemiconjBy a x y → SemiconjBy (MulOpposite.op a) (MulOpposite.op y) (MulOpposite.op x) | true |
CategoryTheory.Functor.CoreMonoidal.toLaxMonoidal.eq_1 | Mathlib.CategoryTheory.Monoidal.Braided.Transport | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.MonoidalCategory C] {D : Type u₂}
[inst_2 : CategoryTheory.Category.{v₂, u₂} D] [inst_3 : CategoryTheory.MonoidalCategory D]
{F : CategoryTheory.Functor C D} (h : F.CoreMonoidal),
h.toLaxMonoidal =
{ ε := h.εIso.hom, μ := fun... | true |
Int.cast_natCast | Mathlib.Data.Int.Cast.Basic | ∀ {R : Type u} [inst : AddGroupWithOne R] (n : ℕ), ↑↑n = ↑n | true |
Asymptotics.IsBigO.integrableAtFilter | Mathlib.MeasureTheory.Integral.Asymptotics | ∀ {α : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NormedAddCommGroup E] {f : α → E} {g : α → F} {l : Filter α}
[inst_1 : MeasurableSpace α] [inst_2 : NormedAddCommGroup F] {μ : MeasureTheory.Measure α} [l.IsMeasurablyGenerated],
f =O[l] g →
StronglyMeasurableAtFilter f l μ → MeasureTheory.IntegrableAtFilte... | true |
SkewMonoidAlgebra.liftNCAlgHom | Mathlib.Algebra.SkewMonoidAlgebra.Lift | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
{B : Type u_5} →
[inst_2 : Semiring A] →
[inst_3 : Algebra k A] →
[inst_4 : Semiring B] →
[inst_5 : Algebra k B] →
... | true |
Real.sin_two_mul | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), Real.sin (2 * x) = 2 * Real.sin x * Real.cos x | true |
CategoryTheory.Limits.hasColimit_of_coequalizer_and_coproduct | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {J : Type w} [inst_1 : CategoryTheory.SmallCategory J]
(F : CategoryTheory.Functor J C) [CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor F.obj)]
[CategoryTheory.Limits.HasColimit (CategoryTheory.Discrete.functor fun f => F.obj f.fst.1)]
[C... | true |
AddGroupConeClass | Mathlib.Algebra.Order.Group.Cone | (S : Type u_1) → (G : outParam (Type u_2)) → [AddCommGroup G] → [SetLike S G] → Prop | true |
Profinite.NobelingProof.spanCone._proof_4 | Mathlib.Topology.Category.Profinite.Nobeling.Basic | ∀ {I : Type u_1} {C : Set (I → Bool)}, TotallyDisconnectedSpace { x // x ∈ C } | false |
List.twoStepInduction._proof_2 | Mathlib.Data.List.Induction | ∀ {α : Type u_1} (x y : α) (xs : List α), (invImage (fun x => x) sizeOfWFRel).1 xs (x :: y :: xs) | false |
isClosed_empty | Mathlib.Topology.Basic | ∀ {X : Type u} [inst : TopologicalSpace X], IsClosed ∅ | true |
AddChar.zmodAddEquiv._proof_3 | Mathlib.Analysis.Fourier.FiniteAbelian.PontryaginDuality | ∀ {n : ℕ} [inst : NeZero n],
Function.Bijective ⇑(AddChar.circleEquivComplex.toAddMonoidHom.comp AddChar.zmodHom.toAddMonoidHom) | false |
Lean.Elab.Term.CollectPatternVars.Context.newArgs | Lean.Elab.PatternVar | Lean.Elab.Term.CollectPatternVars.Context → Array Lean.Term | true |
NegMemClass.neg | Mathlib.Algebra.Group.Subgroup.Defs | {G : Type u_5} → {S : Type u_6} → [inst : Neg G] → [inst_1 : SetLike S G] → [NegMemClass S G] → {H : S} → Neg ↥H | true |
Lean.Elab.Term.PostponeBehavior.ctorElimType | Lean.Elab.SyntheticMVars | {motive : Lean.Elab.Term.PostponeBehavior → Sort u} → ℕ → Sort (max 1 u) | false |
ModuleCat.hom_whiskerLeft | Mathlib.Algebra.Category.ModuleCat.Monoidal.Basic | ∀ {R : Type u} [inst : CommRing R] (L : ModuleCat R) {M N : ModuleCat R} (f : M ⟶ N),
ModuleCat.Hom.hom (CategoryTheory.MonoidalCategoryStruct.whiskerLeft L f) =
LinearMap.lTensor (↑L) (ModuleCat.Hom.hom f) | true |
IsLocalization.orderIsoOfMaximal._proof_7 | Mathlib.RingTheory.Jacobson.Ring | ∀ {R : Type u_1} {S : Type u_2} [inst : CommRing R] [inst_1 : CommRing S] (y : R) [inst_2 : Algebra R S]
[inst_3 : IsLocalization.Away y S] [inst_4 : IsJacobsonRing R] (I : { p // p.IsMaximal ∧ y ∉ p }),
⟨Ideal.comap (algebraMap R S) ↑⟨Ideal.map (algebraMap R S) ↑I, ⋯⟩, ⋯⟩ = I | false |
CategoryTheory.InjectiveResolution.desc.eq_1 | Mathlib.CategoryTheory.Abelian.Injective.Resolution | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C] {Y Z : C} (f : Z ⟶ Y)
(I : CategoryTheory.InjectiveResolution Y) (J : CategoryTheory.InjectiveResolution Z),
CategoryTheory.InjectiveResolution.desc f I J =
J.cocomplex.mkHom I.cocomplex (CategoryTheory.InjectiveResolut... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Paths.0.SimpleGraph.Walk.exists_isPath_forall_isPath_length_le_length.match_1_1 | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u_1} (G : SimpleGraph V) (n : ℕ),
let s := {n | ∃ u v p, p.IsPath ∧ p.length = n};
∀ (motive : n ∈ s → Prop) (x : n ∈ s),
(∀ (w w_1 : V) (w_2 : G.Walk w w_1) (hp : w_2.IsPath) (hn : w_2.length = n), motive ⋯) → motive x | false |
Aesop.ForwardClusterStateStats.casesOn | Aesop.Stats.Basic | {motive : Aesop.ForwardClusterStateStats → Sort u} →
(t : Aesop.ForwardClusterStateStats) →
((slots : ℕ) →
(instantiationStats : Array Aesop.ForwardInstantiationStats) →
motive { slots := slots, instantiationStats := instantiationStats }) →
motive t | false |
HahnSeries.isPWO_support._simp_1 | Mathlib.RingTheory.HahnSeries.Basic | ∀ {Γ : Type u_1} {R : Type u_3} [inst : PartialOrder Γ] [inst_1 : Zero R] (x : HahnSeries Γ R), x.support.IsPWO = True | false |
Primcodable.subtype._proof_1 | Mathlib.Computability.Primrec.Basic | ∀ {α : Type u_1} [inst : Primcodable α] {p : α → Prop} [inst_1 : DecidablePred p] (n : ℕ),
Encodable.encode ((Encodable.decode n).bind fun a => Option.guard (fun b => decide (p b)) a) =
Encodable.encode ((Encodable.decode n).bind fun x => if h : p x then some ⟨x, h⟩ else none) | false |
Equiv.withBotCongr_refl | Mathlib.Order.WithBot | ∀ {α : Type u_1}, (Equiv.refl α).withBotCongr = Equiv.refl (WithBot α) | true |
SeparationQuotient.lift.congr_simp | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} {α : Type u_4} [inst : TopologicalSpace X] (f f_1 : X → α) (e_f : f = f_1)
(hf : ∀ (x y : X), Inseparable x y → f x = f y) (a a_1 : SeparationQuotient X),
a = a_1 → SeparationQuotient.lift f hf a = SeparationQuotient.lift f_1 ⋯ a_1 | true |
ae_restrict_le_codiscreteWithin | Mathlib.MeasureTheory.Topology | ∀ {α : Type u_1} [inst : MeasurableSpace α] [inst_1 : TopologicalSpace α] [SecondCountableTopology α]
{μ : MeasureTheory.Measure α} [MeasureTheory.NoAtoms μ] {U : Set α},
MeasurableSet U → MeasureTheory.ae (μ.restrict U) ≤ Filter.codiscreteWithin U | true |
instNonUnitalCStarAlgebraSubtypePreLpMemAddSubgroupLpTopENNReal._proof_3 | Mathlib.Analysis.CStarAlgebra.lpSpace | ∀ {I : Type u_1} {A : I → Type u_2} [inst : (i : I) → NonUnitalCStarAlgebra (A i)], CStarRing ↥(lp A ⊤) | false |
_private.Mathlib.Data.List.Cycle.0.List.prev_eq_getElem?_idxOf_pred_of_ne_head._proof_1_19 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} {a : α} (x y : α) (tail : List α), a ∈ x :: y :: tail → ¬a = x → a ∈ y :: tail | false |
FreeRing.castFreeCommRing.eq_1 | Mathlib.RingTheory.FreeCommRing | ∀ {α : Type u_1}, FreeRing.castFreeCommRing = ⇑FreeRing.toFreeCommRing | true |
Std.Time.Internal.Bounded.LE.toFin._proof_2 | Std.Time.Internal.Bounded | ∀ {lo hi : ℤ} (n : Std.Time.Internal.Bounded.LE lo hi), 0 ≤ lo → 0 ≤ hi + 1 | false |
MeasurableSpace.mapNatBool | Mathlib.MeasureTheory.MeasurableSpace.CountablyGenerated | (α : Type u_1) → [inst : MeasurableSpace α] → [MeasurableSpace.CountablyGenerated α] → α → ℕ → Bool | true |
UniqueFactorizationMonoid.toNormalizedGCDMonoid._proof_8 | Mathlib.RingTheory.UniqueFactorizationDomain.GCDMonoid | ∀ (α : Type u_1) [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [inst_2 : NormalizationMonoid α]
(a b : α), (Associates.mk a ⊓ Associates.mk b).out ∣ b | false |
BitVec.extractLsb_xor | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {y x : BitVec w} {hi lo : ℕ},
BitVec.extractLsb lo hi (x ^^^ y) = BitVec.extractLsb lo hi x ^^^ BitVec.extractLsb lo hi y | true |
IsNilpotent.of_pow | Mathlib.Algebra.GroupWithZero.Basic | ∀ {R : Type u_3} [inst : MonoidWithZero R] {x : R} {m : ℕ}, IsNilpotent (x ^ m) → IsNilpotent x | true |
CommRingCat.piFanIsLimit | Mathlib.Algebra.Category.Ring.Constructions | {ι : Type u} → (R : ι → CommRingCat) → CategoryTheory.Limits.IsLimit (CommRingCat.piFan R) | true |
DirectSum.fromAddMonoid | Mathlib.Algebra.DirectSum.Basic | {ι : Type v} →
{β : ι → Type w} →
[inst : (i : ι) → AddCommMonoid (β i)] →
[DecidableEq ι] →
{γ : Type u₁} → [inst_2 : AddCommMonoid γ] → (DirectSum ι fun i => γ →+ β i) →+ γ →+ DirectSum ι fun i => β i | true |
IsUnit.eq_one | Mathlib.Algebra.Group.Units.Defs | ∀ {M : Type u_1} [inst : Monoid M] {a : M} [Subsingleton Mˣ], IsUnit a → a = 1 | true |
ValuativeRel.exists_valuation_posSubmonoid_div_valuation_posSubmonoid_eq | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : ValuativeRel R] (γ : (ValuativeRel.ValueGroupWithZero R)ˣ),
∃ a b, (ValuativeRel.valuation R) ↑a / (ValuativeRel.valuation R) ↑b = ↑γ | true |
Unitary.map_comp | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_2} {S : Type u_3} {T : Type u_4} [inst : Monoid R] [inst_1 : StarMul R] [inst_2 : Monoid S]
[inst_3 : StarMul S] [inst_4 : Monoid T] [inst_5 : StarMul T] (g : S →⋆* T) (f : R →⋆* S),
Unitary.map (g.comp f) = (Unitary.map g).comp (Unitary.map f) | true |
Finset.centerMass_pair | Mathlib.Analysis.Convex.Combination | ∀ {R : Type u_1} {E : Type u_3} {ι : Type u_5} [inst : Field R] [inst_1 : AddCommGroup E] [inst_2 : Module R E]
(i j : ι) (w : ι → R) (z : ι → E) [inst_3 : DecidableEq ι],
i ≠ j → {i, j}.centerMass w z = (w i / (w i + w j)) • z i + (w j / (w i + w j)) • z j | true |
_private.Lean.Compiler.LCNF.ExplicitRC.0.Lean.Compiler.LCNF.CollectDerivedValInfo.collect | Lean.Compiler.LCNF.ExplicitRC | Array (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Lean.Compiler.LCNF.Code Lean.Compiler.LCNF.Purity.impure →
Lean.Compiler.LCNF.CompilerM (Lean.Compiler.LCNF.DerivedValMap✝ × Lean.FVarIdHashSet) | true |
ProfiniteAddGrp.instHasForget₂ContinuousAddMonoidHomCarrierToTopTotallyDisconnectedSpaceToProfiniteProfiniteContinuousMap._proof_5 | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X : ProfiniteAddGrp.{u_1}}, CompHausLike.HasProp (fun Y => TotallyDisconnectedSpace ↑Y) ↑X.toProfinite.1 | false |
Mathlib.Tactic.Ring.CSLift.ctorIdx | Mathlib.Tactic.Ring.Basic | {α : Type u} → {β : outParam (Type u)} → Mathlib.Tactic.Ring.CSLift α β → ℕ | false |
GaloisConnection.toGaloisCoinsertion.eq_1 | Mathlib.Order.GaloisConnection.Defs | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {l : α → β} {u : β → α}
(gc : GaloisConnection u l) (h : ∀ (b : β), l (u b) ≤ b),
gc.toGaloisCoinsertion h = { choice := fun x x_1 => l x, gc := gc, u_l_le := h, choice_eq := ⋯ } | true |
ProbabilityTheory.Kernel.IsMarkovKernel.comp | Mathlib.Probability.Kernel.Composition.Comp | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} (η : ProbabilityTheory.Kernel β γ) [ProbabilityTheory.IsMarkovKernel η]
(κ : ProbabilityTheory.Kernel α β) [ProbabilityTheory.IsMarkovKernel κ], ProbabilityTheory.IsMarkovKernel (η.comp κ) | true |
CategoryTheory.Adjunction.leftAdjointIdIso_hom_app | Mathlib.CategoryTheory.Adjunction.CompositionIso | ∀ {C₀ : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C₀] {F G : CategoryTheory.Functor C₀ C₀} (adj : F ⊣ G)
(e : G ≅ CategoryTheory.Functor.id C₀) (X : C₀),
(adj.leftAdjointIdIso e).hom.app X = CategoryTheory.CategoryStruct.comp (F.map (e.inv.app X)) (adj.counit.app X) | true |
_private.Mathlib.RingTheory.Adjoin.Field.0.AlgEquiv.adjoinSingletonEquivAdjoinRootMinpoly._simp_2 | Mathlib.RingTheory.Adjoin.Field | ∀ {R : Type u} {A : Type z} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A] (x : A)
(p : Polynomial R), Polynomial.eval₂ (algebraMap R A) x p = (Polynomial.aeval x) p | false |
_private.Mathlib.Topology.Algebra.ProperAction.Basic.0.t2Space_quotient_mulAction_of_properSMul._simp_4 | Mathlib.Topology.Algebra.ProperAction.Basic | ∀ {α : Type u_1} {β : Type u_2} {p : α × β → Prop}, (∃ x, p x) = ∃ a b, p (a, b) | false |
Sbtw.trans_wbtw_left_ne | Mathlib.Analysis.Convex.Between | ∀ {R : Type u_1} {V : Type u_2} {P : Type u_4} [inst : Ring R] [inst_1 : PartialOrder R] [inst_2 : AddCommGroup V]
[inst_3 : Module R V] [inst_4 : AddTorsor V P] [IsOrderedRing R] [IsDomain R] [Module.IsTorsionFree R V]
{w x y z : P}, Sbtw R w y z → Wbtw R w x y → x ≠ z | true |
ProbabilityTheory.gaussianReal_const_sub | Mathlib.Probability.Distributions.Gaussian.Real | ∀ {μ : ℝ} {v : NNReal} {Ω : Type u_1} {mΩ : MeasurableSpace Ω} {P : MeasureTheory.Measure Ω} {X : Ω → ℝ},
ProbabilityTheory.HasLaw X (ProbabilityTheory.gaussianReal μ v) P →
∀ (y : ℝ), ProbabilityTheory.HasLaw (fun ω => y - X ω) (ProbabilityTheory.gaussianReal (y - μ) v) P | true |
Aesop.RuleStats.mk.injEq | Aesop.Stats.Basic | ∀ (rule : Aesop.DisplayRuleName) (elapsed : Aesop.Nanos) (successful : Bool) (rule_1 : Aesop.DisplayRuleName)
(elapsed_1 : Aesop.Nanos) (successful_1 : Bool),
({ rule := rule, elapsed := elapsed, successful := successful } =
{ rule := rule_1, elapsed := elapsed_1, successful := successful_1 }) =
(rule = r... | true |
BitVec.instDecidableExistsBitVecSucc._proof_1 | Init.Data.BitVec.Decidable | ∀ {n : ℕ} (P : BitVec (n + 1) → Prop), (¬∀ (v : BitVec (n + 1)), ¬P v) ↔ ∃ v, P v | false |
GroupExtension.Section.inv_mul_mem_range_inl | Mathlib.GroupTheory.GroupExtension.Basic | ∀ {N : Type u_1} {G : Type u_2} [inst : Group N] [inst_1 : Group G] {E : Type u_3} [inst_2 : Group E]
{S : GroupExtension N E G} (σ σ' : S.Section) (g : G), (σ g)⁻¹ * σ' g ∈ S.inl.range | true |
Rep.coinvariantsTensorFreeLEquiv._proof_4 | Mathlib.RepresentationTheory.Coinvariants | ∀ {k G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (A : Rep.{u_1, u_1, u_1} k G) (α : Type u_1)
[inst_2 : DecidableEq α], A.finsuppToCoinvariantsTensorFree α ∘ₗ A.coinvariantsTensorFreeToFinsupp α = LinearMap.id | false |
_private.Lean.Meta.Tactic.Grind.AC.Eq.0.PSigma.casesOn._arg_pusher | Lean.Meta.Tactic.Grind.AC.Eq | ∀ {α : Sort u} {β : α → Sort v} {motive : PSigma β → Sort u_1} (α_1 : Sort u✝) (β_1 : α_1 → Sort v✝)
(f : (x : α_1) → β_1 x) (rel : PSigma β → α_1 → Prop) (t : PSigma β)
(mk : (fst : α) → (snd : β fst) → ((y : α_1) → rel ⟨fst, snd⟩ y → β_1 y) → motive ⟨fst, snd⟩),
(PSigma.casesOn (motive := fun t => ((y : α_1) → ... | false |
Lean.Elab.Structural.RecArgInfo._sizeOf_1 | Lean.Elab.PreDefinition.Structural.RecArgInfo | Lean.Elab.Structural.RecArgInfo → ℕ | false |
Finset.fiber_card_ne_zero_iff_mem_image | Mathlib.Data.Finset.Card | ∀ {α : Type u_1} {β : Type u_2} (s : Finset α) (f : α → β) [inst : DecidableEq β] (y : β),
{x ∈ s | f x = y}.card ≠ 0 ↔ y ∈ Finset.image f s | true |
Polynomial.isRoot_cyclotomic_prime_pow_mul_iff_of_charP | Mathlib.RingTheory.Polynomial.Cyclotomic.Expand | ∀ {m k p : ℕ} {R : Type u_1} [inst : CommRing R] [IsDomain R] [hp : Fact (Nat.Prime p)] [hchar : CharP R p] {μ : R}
[NeZero ↑m], (Polynomial.cyclotomic (p ^ k * m) R).IsRoot μ ↔ IsPrimitiveRoot μ m | true |
Stream'.Seq.fold.match_1 | Mathlib.Data.Seq.Defs | {α : Type u_2} →
{β : Type u_1} →
(motive : β × Stream'.Seq α → Sort u_3) →
(x : β × Stream'.Seq α) → ((acc : β) → (x : Stream'.Seq α) → motive (acc, x)) → motive x | false |
Equiv.natSumNatEquivNat | Mathlib.Logic.Equiv.Nat | ℕ ⊕ ℕ ≃ ℕ | true |
Lean.Elab.Tactic.GuardExpr.MatchKind.noConfusionType | Lean.Elab.Tactic.Guard | Sort u → Lean.Elab.Tactic.GuardExpr.MatchKind → Lean.Elab.Tactic.GuardExpr.MatchKind → Sort u | false |
Semiring.mk._flat_ctor | Mathlib.Algebra.Ring.Defs | {α : Type u} →
(add : α → α → α) →
(∀ (a b c : α), a + b + c = a + (b + c)) →
(zero : α) →
(∀ (a : α), 0 + a = a) →
(∀ (a : α), a + 0 = a) →
(nsmul : ℕ → α → α) →
autoParam (∀ (x : α), nsmul 0 x = 0) AddMonoid.nsmul_zero._autoParam →
autoParam (∀ (... | false |
Prod.addAction._proof_1 | Mathlib.Algebra.Group.Action.Prod | ∀ {M : Type u_3} {α : Type u_1} {β : Type u_2} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : AddAction M β]
(x x_1 : M) (x_2 : α × β), (x + x_1) +ᵥ x_2 = x +ᵥ x_1 +ᵥ x_2 | false |
_private.Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody.0.NumberField.mixedEmbedding.convexBodyLT'_mem._simp_1_1 | Mathlib.NumberTheory.NumberField.CanonicalEmbedding.ConvexBody | ∀ {α : Type u} {β : Type v} {s : Set α} {t : Set β} {p : α × β}, (p ∈ s ×ˢ t) = (p.1 ∈ s ∧ p.2 ∈ t) | false |
Array.mapFinIdx_eq_mapIdx | Init.Data.Array.MapIdx | ∀ {α : Type u_1} {β : Type u_2} {xs : Array α} {f : (i : ℕ) → α → i < xs.size → β} {g : ℕ → α → β},
(∀ (i : ℕ) (h : i < xs.size), f i xs[i] h = g i xs[i]) → xs.mapFinIdx f = Array.mapIdx g xs | true |
DivisionMonoid.ctorIdx | Mathlib.Algebra.Group.Defs | {G : Type u} → DivisionMonoid G → ℕ | false |
Lean.Parser.Command.importPath.parenthesizer | Lean.Parser.Command | Lean.PrettyPrinter.Parenthesizer | true |
Fin.val_ofNat | Init.Data.Fin.Lemmas | ∀ (n : ℕ) [inst : NeZero n] (a : ℕ), ↑(Fin.ofNat n a) = a % n | true |
Lean.Language.SnapshotTree.mk.sizeOf_spec | Lean.Language.Basic | ∀ (element : Lean.Language.Snapshot) (children : Array (Lean.Language.SnapshotTask Lean.Language.SnapshotTree)),
sizeOf { element := element, children := children } = 1 + sizeOf element + sizeOf children | true |
Continuous.clog | Mathlib.Analysis.SpecialFunctions.Complex.Log | ∀ {α : Type u_1} [inst : TopologicalSpace α] {f : α → ℂ},
Continuous f → (∀ (x : α), f x ∈ Complex.slitPlane) → Continuous fun t => Complex.log (f t) | true |
HomologicalComplex.mapBifunctor₁₂.d₃_eq_zero | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_... | true |
MultilinearMap.addCommMonoid | Mathlib.LinearAlgebra.Multilinear.Basic | {R : Type uR} →
{ι : Type uι} →
{M₁ : ι → Type v₁} →
{M₂ : Type v₂} →
[inst : Semiring R] →
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] →
[inst_2 : AddCommMonoid M₂] →
[inst_3 : (i : ι) → Module R (M₁ i)] → [inst_4 : Module R M₂] → AddCommMonoid (MultilinearMap R M₁... | true |
IsBezout.span_pair_isPrincipal | Mathlib.RingTheory.PrincipalIdealDomain | ∀ {R : Type u} [inst : Ring R] [IsBezout R] (x y : R), Submodule.IsPrincipal (Ideal.span {x, y}) | true |
PrincipalSeg.isSuccPrelimit_apply_iff | Mathlib.Order.SuccPred.InitialSeg | ∀ {α : Type u_1} {β : Type u_2} {a : α} [inst : PartialOrder α] [inst_1 : PartialOrder β]
(f : PrincipalSeg (fun x1 x2 => x1 < x2) fun x1 x2 => x1 < x2),
Order.IsSuccPrelimit (f.toRelEmbedding a) ↔ Order.IsSuccPrelimit a | true |
CategoryTheory.Limits.WalkingPair.equivBool._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | ∀ (j : CategoryTheory.Limits.WalkingPair),
(fun b => Bool.recOn b CategoryTheory.Limits.WalkingPair.right CategoryTheory.Limits.WalkingPair.left)
((fun x =>
match x with
| CategoryTheory.Limits.WalkingPair.left => true
| CategoryTheory.Limits.WalkingPair.right => false)
j) ... | false |
ProfiniteAddGrp.ofHom_apply | Mathlib.Topology.Algebra.Category.ProfiniteGrp.Basic | ∀ {X Y : Type u} [inst : AddGroup X] [inst_1 : TopologicalSpace X] [inst_2 : IsTopologicalAddGroup X]
[inst_3 : CompactSpace X] [inst_4 : TotallyDisconnectedSpace X] [inst_5 : AddGroup Y] [inst_6 : TopologicalSpace Y]
[inst_7 : IsTopologicalAddGroup Y] [inst_8 : CompactSpace Y] [inst_9 : TotallyDisconnectedSpace Y]... | true |
minimalPrimes | Mathlib.RingTheory.Ideal.MinimalPrime.Basic | (R : Type u_1) → [inst : CommSemiring R] → Set (Ideal R) | true |
Nondet.ofListM | Batteries.Control.Nondet.Basic | {σ : Type} → {m : Type → Type} → [Monad m] → [inst : Lean.MonadBacktrack σ m] → {α : Type} → List (m α) → Nondet m α | true |
CategoryTheory.MonObj._aux_Mathlib_CategoryTheory_Monoidal_Mon____unexpand_CategoryTheory_MonObj_mul_1 | Mathlib.CategoryTheory.Monoidal.Mon_ | Lean.PrettyPrinter.Unexpander | false |
HasFDerivWithinAt.of_restrictScalars | Mathlib.Analysis.Calculus.FDeriv.RestrictScalars | ∀ (𝕜 : Type u_1) [inst : NontriviallyNormedField 𝕜] {𝕜' : Type u_2} [inst_1 : NontriviallyNormedField 𝕜']
[inst_2 : NormedAlgebra 𝕜 𝕜'] {E : Type u_3} [inst_3 : NormedAddCommGroup E] [inst_4 : NormedSpace 𝕜 E]
[inst_5 : NormedSpace 𝕜' E] [inst_6 : IsScalarTower 𝕜 𝕜' E] {F : Type u_4} [inst_7 : NormedAddCo... | true |
_private.Mathlib.NumberTheory.Padics.PadicVal.Basic.0.padicValRat.lt_sum_of_lt._simp_1_1 | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {α : Type u_1} [inst : DecidableEq α] {s : Finset α} {a b : α}, (a ∈ insert b s) = (a = b ∨ a ∈ s) | false |
MulAction.IsBlock.univ | Mathlib.GroupTheory.GroupAction.Blocks | ∀ {G : Type u_1} [inst : Group G] {X : Type u_2} [inst_1 : MulAction G X], MulAction.IsBlock G Set.univ | true |
Std.HashSet.getD_diff_of_not_mem_left | Std.Data.HashSet.Lemmas | ∀ {α : Type u} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.HashSet α} [EquivBEq α] [LawfulHashable α] {k fallback : α},
k ∉ m₁ → (m₁ \ m₂).getD k fallback = fallback | true |
CompHausLike.finiteCoproduct.desc | Mathlib.Topology.Category.CompHausLike.Limits | {P : TopCat → Prop} →
{α : Type w} →
[inst : Finite α] →
(X : α → CompHausLike P) →
[inst_1 : CompHausLike.HasExplicitFiniteCoproduct X] →
{B : CompHausLike P} → ((a : α) → X a ⟶ B) → (CompHausLike.finiteCoproduct X ⟶ B) | true |
ContinuousMap.induction_on | Mathlib.Topology.ContinuousMap.StoneWeierstrass | ∀ {𝕜 : Type u_1} [inst : RCLike 𝕜] {s : Set 𝕜} {p : C(↑s, 𝕜) → Prop},
(∀ (r : 𝕜), p (ContinuousMap.const (↑s) r)) →
p (ContinuousMap.restrict s (ContinuousMap.id 𝕜)) →
p (star (ContinuousMap.restrict s (ContinuousMap.id 𝕜))) →
(∀ (f g : C(↑s, 𝕜)), p f → p g → p (f + g)) →
(∀ (f g :... | true |
_private.Mathlib.Combinatorics.SimpleGraph.Acyclic.0.SimpleGraph.IsTree.card_edgeFinset._simp_1_7 | Mathlib.Combinatorics.SimpleGraph.Acyclic | ∀ {α : Type u_4} {f : Sym2 α → Prop}, (∀ (x : Sym2 α), f x) = ∀ (x y : α), f s(x, y) | false |
List.Vector.continuous_eraseIdx | Mathlib.Topology.List | ∀ {α : Type u_1} [inst : TopologicalSpace α] {n : ℕ} {i : Fin (n + 1)}, Continuous (List.Vector.eraseIdx i) | true |
_private.Mathlib.CategoryTheory.ObjectProperty.FiniteProducts.0.CategoryTheory.ObjectProperty.prop_of_isLimit_fan.match_1_1 | Mathlib.CategoryTheory.ObjectProperty.FiniteProducts | ∀ {J : Type u_1} (motive : CategoryTheory.Discrete J → Prop) (h : CategoryTheory.Discrete J),
(∀ (j : J), motive { as := j }) → motive h | false |
Ordinal.enumOrdOrderIso | Mathlib.SetTheory.Ordinal.Enum | (s : Set Ordinal.{u_1}) → ¬BddAbove s → Ordinal.{u_1} ≃o ↑s | true |
Lean.Parser.Command.checkAssertions.formatter | Lean.Parser.Command | Lean.PrettyPrinter.Formatter | true |
DistribMulActionHom.instOneId | Mathlib.GroupTheory.GroupAction.Hom | {M : Type u_1} →
[inst : Monoid M] → {A : Type u_4} → [inst_1 : AddMonoid A] → [inst_2 : DistribMulAction M A] → One (A →+[M] A) | true |
Std.Internal.List.minEntry?_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : Ord α] [Std.TransOrd α] [inst_2 : BEq α] [Std.LawfulBEqOrd α]
{l l' : List ((a : α) × β a)},
Std.Internal.List.DistinctKeys l → l.Perm l' → Std.Internal.List.minEntry? l = Std.Internal.List.minEntry? l' | true |
Lean.Parser.SyntaxStack.casesOn | Lean.Parser.Types | {motive : Lean.Parser.SyntaxStack → Sort u} →
(t : Lean.Parser.SyntaxStack) →
((raw : Array Lean.Syntax) → (drop : ℕ) → motive { raw := raw, drop := drop }) → motive t | false |
Equiv.Perm.sign_eq_prod_prod_Ioi | Mathlib.GroupTheory.Perm.Fin | ∀ {n : ℕ} (σ : Equiv.Perm (Fin n)), Equiv.Perm.sign σ = ∏ i, ∏ j ∈ Finset.Ioi i, if σ i < σ j then 1 else -1 | true |
FormalMultilinearSeries.ofScalarsSum | Mathlib.Analysis.Analytic.OfScalars | {𝕜 : Type u_1} →
{E : Type u_2} →
[inst : Field 𝕜] →
[inst_1 : Ring E] → [Algebra 𝕜 E] → [inst : TopologicalSpace E] → [IsTopologicalRing E] → (ℕ → 𝕜) → E → E | true |
FP.Float.inf.inj | Mathlib.Data.FP.Basic | ∀ {C : FP.FloatCfg} {a a_1 : Bool}, FP.Float.inf a = FP.Float.inf a_1 → a = a_1 | true |
_private.Mathlib.LinearAlgebra.Isomorphisms.0.LinearMap.quotientInfEquivSupQuotient_surjective._simp_1_2 | Mathlib.LinearAlgebra.Isomorphisms | ∀ {R : Type u_1} {R₂ : Type u_3} {M : Type u_5} {M₂ : Type u_7} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂}
{x : M} {f : M →ₛₗ[σ₁₂] M₂} {p : Submodule R₂ M₂}, (x ∈ Submodule.comap f p) = (f x ∈ p) | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.