name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11.5k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.sym2_eq_sym_two | Mathlib.Data.List.Sym | ∀ {α : Type u_1} {xs : List α}, List.map (⇑(Sym2.equivSym α)) xs.sym2 = List.sym 2 xs | null | true |
Equiv.Perm.extendDomain_apply_subtype | Mathlib.Logic.Equiv.Basic | ∀ {α' : Type u_9} {β' : Type u_10} (e : Equiv.Perm α') {p : β' → Prop} [inst : DecidablePred p] (f : α' ≃ Subtype p)
{b : β'} (h : p b), (e.extendDomain f) b = ↑(f (e (f.symm ⟨b, h⟩))) | null | true |
Group.IsFinitelyPresented.casesOn | Mathlib.GroupTheory.FinitelyPresentedGroup | {G : Type u_5} →
[inst : Group G] →
{motive : Group.IsFinitelyPresented G → Sort u} →
(t : Group.IsFinitelyPresented G) →
((out : ∃ n φ, Function.Surjective ⇑φ ∧ φ.ker.IsNormalClosureFG) → motive ⋯) → motive t | null | false |
Std.Internal.Parsec.pure | Std.Internal.Parsec.Basic | {α ι : Type} → α → Std.Internal.Parsec ι α | null | true |
Nat.ModEq.add_iff_left._simp_1 | Mathlib.Data.Nat.ModEq | ∀ {n a b c d : ℕ}, a ≡ b [MOD n] → (a + c ≡ b + d [MOD n]) = (c ≡ d [MOD n]) | null | false |
Function.Injective.involutiveInv.eq_1 | Mathlib.Algebra.Group.InjSurj | ∀ {M₂ : Type u_2} {M₁ : Type u_3} [inst : Inv M₁] [inst_1 : InvolutiveInv M₂] (f : M₁ → M₂) (hf : Function.Injective f)
(inv : ∀ (x : M₁), f x⁻¹ = (f x)⁻¹), Function.Injective.involutiveInv f hf inv = { toInv := inst, inv_inv := ⋯ } | null | true |
Int8.toInt32_neg_of_ne | Init.Data.SInt.Lemmas | ∀ {x : Int8}, x ≠ -128 → (-x).toInt32 = -x.toInt32 | null | true |
_private.Mathlib.NumberTheory.ZetaValues.0.bernoulliFun_eval_half_eq_zero._simp_1_1 | Mathlib.NumberTheory.ZetaValues | ∀ {α : Type u_2} [inst : AddMonoidWithOne α], Even 2 = True | null | false |
CategoryTheory.MorphismProperty.instIsStableUnderCoproductsLlp | Mathlib.CategoryTheory.MorphismProperty.LiftingProperty | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (T : CategoryTheory.MorphismProperty C),
CategoryTheory.MorphismProperty.IsStableUnderCoproducts.{w, v, u} T.llp | null | true |
_private.Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule.0.Lean.Meta.Grind.Arith.Linear.ofNatModule'._unsafe_rec | Lean.Meta.Tactic.Grind.Arith.Linear.OfNatModule | Lean.Expr → Lean.Meta.Grind.Arith.Linear.OfNatModuleM (Lean.Expr × Lean.Expr) | null | false |
Ideal.mem_prod | Mathlib.RingTheory.Ideal.Prod | ∀ {R : Type u} {S : Type v} [inst : Semiring R] [inst_1 : Semiring S] (I : Ideal R) (J : Ideal S) {x : R × S},
x ∈ I.prod J ↔ x.1 ∈ I ∧ x.2 ∈ J | null | true |
MeasurableEquiv.coe_mulLeft | Mathlib.MeasureTheory.Group.MeasurableEquiv | ∀ {G : Type u_1} [inst : Group G] [inst_1 : MeasurableSpace G] [inst_2 : MeasurableMul G] (g : G),
⇑(MeasurableEquiv.mulLeft g) = fun x => g * x | null | true |
MeasureTheory.toOuterMeasure_eq_inducedOuterMeasure | Mathlib.MeasureTheory.Measure.MeasureSpaceDef | ∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α},
μ.toOuterMeasure = MeasureTheory.inducedOuterMeasure (fun s x => μ s) ⋯ ⋯ | null | true |
ProofWidgets.Penrose.DiagramBuilderM.addEmbed | ProofWidgets.Component.PenroseDiagram | String → String → ProofWidgets.Html → ProofWidgets.Penrose.DiagramBuilderM Unit | Add an object `nm` of Penrose type `tp`,
labelled by `h`, to the substance program. | true |
String.Pos.Raw.Valid.mk | Batteries.Data.String.Lemmas | ∀ (cs cs' : List Char) {p : String.Pos.Raw},
p.byteIdx = String.utf8Len cs → String.Pos.Raw.Valid (String.ofList (cs ++ cs')) p | A string position is valid if it is equal to the UTF-8 length of an initial substring of `s`.
| true |
_private.Mathlib.MeasureTheory.Measure.WithDensity.0.MeasureTheory.lintegral_withDensity_eq_lintegral_mul₀'._simp_1_2 | Mathlib.MeasureTheory.Measure.WithDensity | ∀ {α : Type u} (s : Set α) (x : α), (x ∈ sᶜ) = (x ∉ s) | null | false |
_private.Mathlib.Analysis.Complex.ValueDistribution.Cartan.0.ValueDistribution.eventuallyEq_log_trailingCoeff_of_meromorphicOrderAt_eq_zero | Mathlib.Analysis.Complex.ValueDistribution.Cartan | ∀ {f : ℂ → ℂ},
MeromorphicAt f 0 →
meromorphicOrderAt f 0 = 0 →
(fun x => Real.log ‖meromorphicTrailingCoeffAt f 0 - x‖) =ᶠ[Filter.codiscreteWithin (Metric.sphere 0 |1|)]
fun a => Real.log ‖meromorphicTrailingCoeffAt (fun x => f x - a) 0‖ | null | true |
CategoryTheory.Limits.IsLimit.ofConeOfConeUncurry | Mathlib.CategoryTheory.Limits.Fubini | {J : Type u_1} →
{K : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} J] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} K] →
{C : Type u_3} →
[inst_2 : CategoryTheory.Category.{v_3, u_3} C] →
{F : CategoryTheory.Functor J (CategoryTheory.Functor K C)} →
{D ... | If `coneOfConeUncurry Q c` is a limit cone then `c` is in fact a limit cone.
| true |
CategoryTheory.Limits.Trident.ofι_pt | Mathlib.CategoryTheory.Limits.Shapes.WideEqualizers | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C} {f : J → (X ⟶ Y)} [inst_1 : Nonempty J]
{P : C} (ι : P ⟶ X)
(w : ∀ (j₁ j₂ : J), CategoryTheory.CategoryStruct.comp ι (f j₁) = CategoryTheory.CategoryStruct.comp ι (f j₂)),
(CategoryTheory.Limits.Trident.ofι ι w).pt = P | null | true |
ProbabilityTheory.condVar_of_sigmaFinite | Mathlib.Probability.CondVar | ∀ {Ω : Type u_1} {m₀ m : MeasurableSpace Ω} {hm : m ≤ m₀} {X : Ω → ℝ} {μ : MeasureTheory.Measure Ω}
[inst : MeasureTheory.SigmaFinite (μ.trim hm)],
ProbabilityTheory.condVar m X μ =
if MeasureTheory.Integrable (fun ω => (X ω - μ[X | m] ω) ^ 2) μ then
if MeasureTheory.StronglyMeasurable fun ω => (X ω - μ[X... | null | true |
MeasureTheory.SignedMeasure.HaveLebesgueDecomposition.negPart | Mathlib.MeasureTheory.VectorMeasure.Decomposition.Lebesgue | ∀ {α : Type u_1} {m : MeasurableSpace α} {s : MeasureTheory.SignedMeasure α} {μ : MeasureTheory.Measure α}
[self : s.HaveLebesgueDecomposition μ], s.toJordanDecomposition.negPart.HaveLebesgueDecomposition μ | null | true |
Std.DTreeMap.Internal.Impl.foldrM.eq_1 | Std.Data.DTreeMap.Internal.WF.Lemmas | ∀ {α : Type u} {β : α → Type v} {δ : Type w} {m : Type w → Type u_1} [inst : Monad m] (f : (a : α) → β a → δ → m δ)
(init : δ), Std.DTreeMap.Internal.Impl.foldrM f init Std.DTreeMap.Internal.Impl.leaf = pure init | null | true |
OrderDual.instLocallyFiniteOrderTop | Mathlib.Order.Interval.Finset.Defs | {α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderBot α] → LocallyFiniteOrderTop αᵒᵈ | Note we define `Ici (toDual a)` as `Iic a` (which has type `Finset α` not `Finset αᵒᵈ`!)
instead of `(Iic a).map toDual.toEmbedding` as this means the following is defeq:
```
lemma this : (Ici (toDual (toDual a)) :) = (Ici a :) := rfl
```
| true |
Sum.getLeft.congr_simp | Init.Data.Sum.Basic | ∀ {α : Type u_1} {β : Type u_2} (ab ab_1 : α ⊕ β) (e_ab : ab = ab_1) (a : ab.isLeft = true),
ab.getLeft a = ab_1.getLeft ⋯ | null | true |
_private.Mathlib.Data.List.Basic.0.List.erase_getElem._proof_1_3 | Mathlib.Data.List.Basic | ∀ {ι : Type u_1} (a : ι) (l : List ι) (n : ℕ), n + 1 < (a :: l).length → n < l.length | null | false |
ContractingWith.edist_efixedPoint_lt_top | Mathlib.Topology.MetricSpace.Contracting | ∀ {α : Type u_1} [inst : EMetricSpace α] {K : NNReal} {f : α → α} [inst_1 : CompleteSpace α] (hf : ContractingWith K f)
{x : α} (hx : edist x (f x) ≠ ⊤), edist x (ContractingWith.efixedPoint f hf x hx) < ⊤ | null | true |
CategoryTheory.LocallyDiscrete.mkPseudofunctor._proof_1 | Mathlib.CategoryTheory.Bicategory.Functor.LocallyDiscrete | ∀ {B₀ : Type u_4} {C : Type u_2} [inst : CategoryTheory.Category.{u_5, u_4} B₀] [inst_1 : CategoryTheory.Bicategory C]
(obj : B₀ → C) (map : {b b' : B₀} → (b ⟶ b') → (obj b ⟶ obj b')) {b₀ b₁ b₂ b₃ : CategoryTheory.LocallyDiscrete B₀}
(x : b₀ ⟶ b₁) (x_1 : b₁ ⟶ b₂) (x_2 : b₂ ⟶ b₃),
map (CategoryTheory.CategoryStruc... | null | false |
CategoryTheory.Grothendieck.forget | Mathlib.CategoryTheory.Grothendieck | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
(F : CategoryTheory.Functor C CategoryTheory.Cat) → CategoryTheory.Functor (CategoryTheory.Grothendieck F) C | The forgetful functor from `Grothendieck F` to the source category. | true |
_private.Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile.0.Std.IterM.step_intermediateDropWhileWithPostcondition.match_3.eq_1 | Std.Data.Iterators.Lemmas.Combinators.Monadic.DropWhile | ∀ {α : Type u_1} {m : Type u_1 → Type u_2} {β : Type u_1} [inst : Std.Iterator α m β] {it : Std.IterM m β}
(motive : it.Step → Sort u_3) (it' : Std.IterM m β) (out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.IterM m β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yi... | null | true |
Lean.Grind.Linarith.eq_coeff_cert.eq_1 | Init.Grind.Ordered.Linarith | ∀ (p₁ p₂ : Lean.Grind.Linarith.Poly) (k : ℕ), Lean.Grind.Linarith.eq_coeff_cert p₁ p₂ k = (k != 0 && p₁ == p₂.mul ↑k) | null | true |
Algebra.Etale.inst | Mathlib.RingTheory.Etale.Basic | ∀ {R : Type u} [inst : CommRing R], Algebra.Etale R R | null | true |
Std.Http.Response.Builder.line._default | Std.Http.Data.Response | Std.Http.Response.Head | null | false |
CategoryTheory.ObjectProperty.colimitsClosure.of_mem | Mathlib.CategoryTheory.ObjectProperty.ColimitsClosure | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {P : CategoryTheory.ObjectProperty C} {α : Type t}
{J : α → Type u'} [inst_1 : (a : α) → CategoryTheory.Category.{v', u'} (J a)] (X : C), P X → P.colimitsClosure J X | null | true |
Lean.Lsp.ParameterInformationLabel.range.elim | Lean.Data.Lsp.LanguageFeatures | {motive : Lean.Lsp.ParameterInformationLabel → Sort u} →
(t : Lean.Lsp.ParameterInformationLabel) →
t.ctorIdx = 1 →
((startUtf16Offset endUtf16Offset : ℕ) →
motive (Lean.Lsp.ParameterInformationLabel.range startUtf16Offset endUtf16Offset)) →
motive t | null | false |
ENat.one_epow | Mathlib.Data.ENat.Pow | ∀ {y : ℕ∞}, 1 ^ y = 1 | null | true |
AlgebraicGeometry.Scheme.OpenCover.ext_elem | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {X : AlgebraicGeometry.Scheme} {U : X.Opens} (f g : ↑(X.presheaf.obj (Opposite.op U))) (𝒰 : X.OpenCover),
(∀ (i : 𝒰.I₀),
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (𝒰.f i) U)) f =
(CategoryTheory.ConcreteCategory.hom (AlgebraicGeometry.Scheme.Hom.app (𝒰.f i) U)) g) →
... | If two global sections agree after restriction to each member of an open cover, then
they agree globally. | true |
IncidenceAlgebra.instModule._proof_6 | Mathlib.Combinatorics.Enumerative.IncidenceAlgebra | ∀ {𝕜 : Type u_1} {𝕝 : Type u_3} {α : Type u_2} [inst : Preorder α] [inst_1 : LocallyFiniteOrder α] [inst_2 : Semiring 𝕜]
[inst_3 : Semiring 𝕝] [inst_4 : Module 𝕜 𝕝] (x y : IncidenceAlgebra 𝕜 α) (z : IncidenceAlgebra 𝕝 α),
(x • y) • z = x • y • z | null | false |
HomologicalComplex.opInverse._proof_4 | Mathlib.Algebra.Homology.Opposite | ∀ {ι : Type u_3} (V : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} V] (c : ComplexShape ι)
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms V] {X Y Z : HomologicalComplex Vᵒᵖ c.symm} (f : X ⟶ Y) (g : Y ⟶ Z),
Quiver.Hom.op { f := fun i => ((CategoryTheory.CategoryStruct.comp f g).f i).unop, comm' := ⋯ } =
... | null | false |
IsGroupLikeElem.mul | Mathlib.RingTheory.Bialgebra.GroupLike | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Bialgebra R A] {a b : A},
IsGroupLikeElem R a → IsGroupLikeElem R b → IsGroupLikeElem R (a * b) | Group-like elements in a bialgebra are stable under multiplication. | true |
CochainComplex.degreewiseEpiWithInjectiveKernel._proof_1 | Mathlib.Algebra.Homology.Factorizations.Basic | IsRightCancelAdd ℤ | null | false |
Lean.Server.RpcEncodable.mk | Lean.Server.Rpc.Basic | {α : Type} →
(α → StateM Lean.Server.RpcObjectStore Lean.Json) →
(Lean.Json → ExceptT String (ReaderT Lean.Server.RpcObjectStore Id) α) → Lean.Server.RpcEncodable α | null | true |
PolynomialModule.funLike_eq | Mathlib.Algebra.Polynomial.Module.Basic | ∀ (R : Type u_1) {M : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup M] [inst_2 : Module R M]
(x : PolynomialModule R M), ⇑x = ⇑x | Workaround to defeq problems: if we interpret a `PolynomialModule` as a `Finsupp`, also transfer
the `DFunLike` instance. | true |
CompHausLike.coproductIsColimit._proof_6 | Mathlib.Topology.Category.CompHausLike.Cartesian | ∀ {P : TopCat → Prop} (X Y : CompHausLike P) (s : CategoryTheory.Limits.BinaryCofan X Y),
CompHausLike.HasProp P ↑s.1.toTop | null | false |
CategoryTheory.IsGrothendieckAbelian.instMonoIMonomorphismsRlpMonoMapFactorizationDataRlp | Mathlib.CategoryTheory.Abelian.GrothendieckCategory.EnoughInjectives | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.IsGrothendieckAbelian.{w, v, u} C] {X Y : C} (f : X ⟶ Y),
CategoryTheory.Mono (CategoryTheory.IsGrothendieckAbelian.monoMapFactorizationDataRlp f).i | null | true |
Std.Internal.List.containsKey_of_perm | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [PartialEquivBEq α] {l l' : List ((a : α) × β a)} {k : α},
l.Perm l' → Std.Internal.List.containsKey k l = Std.Internal.List.containsKey k l' | null | true |
OrderIso.divRight_symm_apply | Mathlib.Algebra.Order.Group.OrderIso | ∀ {α : Type u} [inst : Group α] [inst_1 : LE α] [inst_2 : MulRightMono α] (a b : α),
(RelIso.symm (OrderIso.divRight a)) b = b * a | null | true |
tendsto_inv_atTop_nhds_zero_nat | Mathlib.Analysis.SpecificLimits.Basic | ∀ {𝕜 : Type u_4} [inst : DivisionSemiring 𝕜] [inst_1 : CharZero 𝕜] [inst_2 : TopologicalSpace 𝕜] [ContinuousSMul ℚ≥0 𝕜],
Filter.Tendsto (fun n => (↑n)⁻¹) Filter.atTop (nhds 0) | null | true |
BitVec.ushiftRight_eq'._simp_1 | Std.Tactic.BVDecide.Normalize.Canonicalize | ∀ {w₁ w₂ : ℕ} (x : BitVec w₁) (y : BitVec w₂), x >>> y.toNat = x >>> y | null | false |
Language.toDFA | Mathlib.Computability.MyhillNerode | {α : Type u} → (L : Language α) → DFA α ↑(Set.range L.leftQuotient) | The left quotients of a language are the states of an automaton that accepts the language. | true |
Monoid.mk._flat_ctor | Mathlib.Algebra.Group.Defs | {M : Type u} →
(mul : M → M → M) →
(∀ (a b c : M), a * b * c = a * (b * c)) →
(one : M) →
(∀ (a : M), 1 * a = a) →
(∀ (a : M), a * 1 = a) →
(npow : ℕ → M → M) →
autoParam (∀ (x : M), npow 0 x = 1) Monoid.npow_zero._autoParam →
autoParam (∀ (n : ℕ) ... | null | false |
Lean.Parser.instInhabitedParserInfo.default | Lean.Parser.Types | Lean.Parser.ParserInfo | null | true |
Std.List.stream_drop_eq_drop | Batteries.Data.Stream | ∀ {α : Type u_1} {n : ℕ} (l : List α), Std.Stream.drop l n = List.drop n l | null | true |
SimpleGraph.Iso.map._proof_3 | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_2} {W : Type u_1} (f : V ≃ W) (G : SimpleGraph V) {a b : V},
(SimpleGraph.map (⇑f) G).Adj (f a) (f b) ↔ G.Adj a b | null | false |
_private.Mathlib.NumberTheory.DiophantineApproximation.Basic.0.Real.invariant._simp_1_3 | Mathlib.NumberTheory.DiophantineApproximation.Basic | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False | null | false |
CommGroupWithZero.zpow._inherited_default | Mathlib.Algebra.GroupWithZero.Defs | {G₀ : Type u_2} → (G₀ → G₀ → G₀) → G₀ → (G₀ → G₀) → ℤ → G₀ → G₀ | null | false |
Polynomial.eq_X_add_C_of_natDegree_le_one | Mathlib.Algebra.Polynomial.Degree.SmallDegree | ∀ {R : Type u} [inst : Semiring R] {p : Polynomial R},
p.natDegree ≤ 1 → p = Polynomial.C (p.coeff 1) * Polynomial.X + Polynomial.C (p.coeff 0) | null | true |
MvPolynomial.renameEquiv_trans | Mathlib.Algebra.MvPolynomial.Rename | ∀ {σ : Type u_1} {τ : Type u_2} {α : Type u_3} (R : Type u_4) [inst : CommSemiring R] (e : σ ≃ τ) (f : τ ≃ α),
(MvPolynomial.renameEquiv R e).trans (MvPolynomial.renameEquiv R f) = MvPolynomial.renameEquiv R (e.trans f) | null | true |
Units.instMulDistribMulAction._proof_1 | Mathlib.Algebra.GroupWithZero.Action.Units | ∀ {M : Type u_1} {α : Type u_2} [inst : Monoid M] [inst_1 : Monoid α] [inst_2 : MulDistribMulAction M α] (m : Mˣ),
↑m • 1 = 1 | null | false |
Polynomial.isOpenMap_comap_C | Mathlib.RingTheory.Spectrum.Prime.Polynomial | ∀ {R : Type u_1} [inst : CommRing R], IsOpenMap (PrimeSpectrum.comap Polynomial.C) | null | true |
_private.Mathlib.GroupTheory.SpecificGroups.Alternating.0.alternatingGroup.conj_smul_range_ofSubtype._simp_1_5 | Mathlib.GroupTheory.SpecificGroups.Alternating | ∀ {α : Type u_2} {β : Type u_3} [inst : DecidableEq β] [inst_1 : Group α] [inst_2 : MulAction α β] {s t : Finset β}
{a : α}, (s ⊆ a • t) = (a⁻¹ • s ⊆ t) | null | false |
Array.takeWhile_map | Init.Data.Array.Extract | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {p : β → Bool} {as : Array α},
Array.takeWhile p (Array.map f as) = Array.map f (Array.takeWhile (p ∘ f) as) | null | true |
_private.Mathlib.Data.Fintype.EquivFin.0.Function.Embedding.exists_of_card_eq_finset._simp_1_1 | Mathlib.Data.Fintype.EquivFin | ∀ {α : Type u_1} {s₁ s₂ : Finset α}, (s₁ ⊆ s₂) = (↑s₁ ⊆ ↑s₂) | null | false |
Std.ExtDTreeMap.self_le_maxKey!_insert | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.ExtDTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β k}, (cmp k (t.insert k v).maxKey!).isLE = true | null | true |
_private.Lean.Elab.Tactic.Simp.0.Lean.Elab.Tactic.elabSimpArgs.match_11 | Lean.Elab.Tactic.Simp | (motive : Lean.Elab.Tactic.ElabSimpArgResult → Sort u_1) →
(arg : Lean.Elab.Tactic.ElabSimpArgResult) →
((entries : Array Lean.Meta.SimpEntry) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addEntries entries)) →
((fvarId : Lean.FVarId) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addLetToUnfold fvarId)) →
... | null | false |
Module.Presentation.cokernelRelations_R | Mathlib.Algebra.Module.Presentation.Cokernel | ∀ {A : Type u} [inst : Ring A] {M₁ : Type v₁} {M₂ : Type v₂} [inst_1 : AddCommGroup M₁] [inst_2 : Module A M₁]
[inst_3 : AddCommGroup M₂] [inst_4 : Module A M₂] (pres₂ : Module.Presentation A M₂) {f : M₁ →ₗ[A] M₂} {ι : Type w₁}
{g₁ : ι → M₁} (data : pres₂.CokernelData f g₁), (pres₂.cokernelRelations data).R = (pres... | null | true |
ValuativeRel._aux_Mathlib_RingTheory_Valuation_ValuativeRel_Basic___unexpand_ValuativeRel_vlt_1 | Mathlib.RingTheory.Valuation.ValuativeRel.Basic | Lean.PrettyPrinter.Unexpander | null | false |
BooleanAlgebra.toHImp | Mathlib.Order.BooleanAlgebra.Defs | {α : Type u} → [self : BooleanAlgebra α] → HImp α | null | true |
QuotientAddGroup.circularPreorder._proof_7 | Mathlib.Algebra.Order.ToIntervalMod | ∀ {α : Type u_1} [inst : AddCommGroup α] [inst_1 : LinearOrder α] [inst_2 : IsOrderedAddMonoid α] [hα : Archimedean α]
{p : α} [hp' : Fact (0 < p)] {x₁ x₂ x₃ : α ⧸ AddSubgroup.zmultiples p}, btw x₁ x₂ x₃ → btw x₂ x₃ x₁ | null | false |
DiscreteQuotient.map_continuous | Mathlib.Topology.DiscreteQuotient | ∀ {X : Type u_2} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : C(X, Y)}
{A : DiscreteQuotient X} {B : DiscreteQuotient Y} (cond : DiscreteQuotient.LEComap f A B),
Continuous (DiscreteQuotient.map f cond) | null | true |
instIsCancelVAdd | Mathlib.Algebra.Group.Action.Defs | ∀ (G : Type u_9) [inst : AddCancelMonoid G], IsCancelVAdd G G | null | true |
AddCommMonCat.Hom.recOn | Mathlib.Algebra.Category.MonCat.Basic | {A B : AddCommMonCat} →
{motive : A.Hom B → Sort u_1} → (t : A.Hom B) → ((hom' : ↑A →+ ↑B) → motive { hom' := hom' }) → motive t | null | false |
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.le_singleton._simp_1_1 | Mathlib.Data.Multiset.ZeroCons | ∀ {α : Type u_1} (a : α), {a} = ↑[a] | null | false |
GromovHausdorff.instInhabitedGHSpace | Mathlib.Topology.MetricSpace.GromovHausdorff | Inhabited GromovHausdorff.GHSpace | null | true |
Lean.Syntax.topDown | Lean.Syntax | Lean.Syntax → optParam Bool false → Lean.Syntax.TopDown | `for _ in stx.topDown` iterates through each node and leaf in `stx` top-down, left-to-right.
If `firstChoiceOnly` is `true`, only visit the first argument of each choice node.
| true |
MultilinearMap.uncurry_curryRight | Mathlib.LinearAlgebra.Multilinear.Curry | ∀ {R : Type uR} {n : ℕ} {M : Fin n.succ → Type v} {M₂ : Type v₂} [inst : CommSemiring R]
[inst_1 : (i : Fin n.succ) → AddCommMonoid (M i)] [inst_2 : AddCommMonoid M₂]
[inst_3 : (i : Fin n.succ) → Module R (M i)] [inst_4 : Module R M₂] (f : MultilinearMap R M M₂),
f.curryRight.uncurryRight = f | null | true |
List.eraseIdx_eq_self | Init.Data.List.Erase | ∀ {α : Type u_1} {l : List α} {k : ℕ}, l.eraseIdx k = l ↔ l.length ≤ k | null | true |
Lean.Grind.IntModule.OfNatModule.r | Init.Grind.Module.Envelope | (α : Type u) → [Lean.Grind.NatModule α] → α × α → α × α → Prop | null | true |
SeparationQuotient.surjective_mk | Mathlib.Topology.Inseparable | ∀ {X : Type u_1} [inst : TopologicalSpace X], Function.Surjective SeparationQuotient.mk | null | true |
neg_add_cancel_left | Mathlib.Algebra.Group.Defs | ∀ {G : Type u_1} [inst : AddGroup G] (a b : G), -a + (a + b) = b | null | true |
Std.Tactic.BVDecide.BVExpr.bitblast.instLawfulVecOperatorRefVecBlastClz | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Clz | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α],
Std.Sat.AIG.LawfulVecOperator α Std.Sat.AIG.RefVec fun {len} => Std.Tactic.BVDecide.BVExpr.bitblast.blastClz | null | true |
CategoryTheory.over._auto_1 | Mathlib.CategoryTheory.Comma.Over.OverClass | Lean.Syntax | null | false |
Std.DTreeMap.Internal.Impl.minKeyD_erase_eq_of_not_compare_minKeyD_eq | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [Std.TransOrd α] (h : t.WF)
{k fallback : α},
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.isEmpty = false →
¬compare k (t.minKeyD fallback) = Ordering.eq →
(Std.DTreeMap.Internal.Impl.erase k t ⋯).impl.minKeyD fallbac... | null | true |
_private.Mathlib.Tactic.Linter.FlexibleLinter.0.Mathlib.Linter.Flexible.generateSimpSuggestion | Mathlib.Tactic.Linter.FlexibleLinter | Mathlib.Linter.Flexible.StainData✝ → Lean.Syntax → Lean.CoreM (Option Lean.Syntax) | Generate a "simp only [...]" suggestion for a simp/simpAll tactic.
Returns `none` if the tactic is not simp/simpAll or if suggestion generation fails. | true |
IsClosedMap.codRestrict | Mathlib.Topology.Constructions | ∀ {X : Type u} {Y : Type v} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y] {f : X → Y},
IsClosedMap f → ∀ {s : Set Y} (hs : ∀ (a : X), f a ∈ s), IsClosedMap (Set.codRestrict f s hs) | null | true |
_private.Mathlib.Topology.Algebra.Valued.NormedValued.0.Valuation.norm_add_le._simp_1_3 | Mathlib.Topology.Algebra.Valued.NormedValued | ∀ {α : Type u} [inst : LinearOrder α] {a b c : α}, (a ≤ max b c) = (a ≤ b ∨ a ≤ c) | null | false |
Option.any_none | Init.Data.Option.Basic | ∀ {α : Type u_1} {p : α → Bool}, Option.any p none = false | null | true |
CochainComplex.HomComplex.Cochain.single_v | Mathlib.Algebra.Homology.HomotopyCategory.HomComplex | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
{K L : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ L.X q) (n : ℤ) (hpq : p + n = q),
(CochainComplex.HomComplex.Cochain.single f n).v p q hpq = f | null | true |
Lean.Elab.enableInfoTree | Lean.Elab.InfoTree.Main | {m : Type → Type} → [Lean.Elab.MonadInfoTree m] → optParam Bool true → m Unit | null | true |
HeytingAlgebra.ctorIdx | Mathlib.Order.Heyting.Basic | {α : Type u_4} → HeytingAlgebra α → ℕ | null | false |
_private.Mathlib.Algebra.Order.Field.Basic.0.Mathlib.Meta.Positivity.evalInv.match_3 | Mathlib.Algebra.Order.Field.Basic | {u : Lean.Level} →
{α : Q(Type u)} →
(zα : Q(Zero «$α»)) →
(pα : Q(PartialOrder «$α»)) →
(a : Q(«$α»)) →
(motive : Mathlib.Meta.Positivity.Strictness zα pα a → Sort u_1) →
(ra : Mathlib.Meta.Positivity.Strictness zα pα a) →
((pa : Q(0 < «$a»)) → motive (Mathlib.Me... | null | false |
frequently_gt_nhds | Mathlib.Topology.Order.LeftRight | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : Preorder α] (a : α) [(nhdsWithin a (Set.Ioi a)).NeBot],
∃ᶠ (x : α) in nhds a, a < x | null | true |
Set.biUnionEqSigmaOfDisjoint.eq_1 | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s : Set ι} {f : ι → Set α} (h : s.PairwiseDisjoint f),
Set.biUnionEqSigmaOfDisjoint h = (Equiv.setCongr ⋯).trans (Set.unionEqSigmaOfDisjoint ⋯) | null | true |
_private.Init.Data.SInt.Bitwise.0.Int8.not_eq_comm._simp_1_1 | Init.Data.SInt.Bitwise | ∀ {a b : Int8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
Relation.map_map | Mathlib.Logic.Relation | ∀ {α : Sort u_1} {β : Sort u_2} {γ : Sort u_3} {δ : Sort u_4} {ε : Sort u_5} {ζ : Sort u_6} (r : α → β → Prop)
(f₁ : α → γ) (g₁ : β → δ) (f₂ : γ → ε) (g₂ : δ → ζ),
Relation.Map (Relation.Map r f₁ g₁) f₂ g₂ = Relation.Map r (f₂ ∘ f₁) (g₂ ∘ g₁) | null | true |
_private.Mathlib.CategoryTheory.FiberedCategory.BasedCategory.0.CategoryTheory.BasedNatTrans.instReflectsIsomorphismsBasedFunctorFunctorObjForgetful._simp_1 | Mathlib.CategoryTheory.FiberedCategory.BasedCategory | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₂} 𝒳] [inst_1 : CategoryTheory.Category.{v₂, u₁} 𝒮]
(p : CategoryTheory.Functor 𝒳 𝒮) (S : 𝒮) {a b : 𝒳} (φ : a ⟶ b) [inst_2 : CategoryTheory.IsIso φ]
[p.IsHomLift (CategoryTheory.CategoryStruct.id S) φ],
p.IsHomLift (CategoryTheory.Categor... | null | false |
MeasureTheory.measure_eq_measure_smaller_of_between_null_diff | Mathlib.MeasureTheory.Measure.MeasureSpace | ∀ {α : Type u_1} {m : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ s₃ : Set α},
s₁ ⊆ s₂ → s₂ ⊆ s₃ → μ (s₃ \ s₁) = 0 → μ s₁ = μ s₂ | **Alias** of `MeasureTheory.measure_eq_measure_smaller_of_between_null_sdiff`. | true |
_private.Mathlib.Algebra.Lie.Weights.IsSimple.0.LieAlgebra.IsKilling.chi_not_in_q_aux.match_1_3 | 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... | null | false |
Subgroup.orderIsoCon | Mathlib.GroupTheory.QuotientGroup.Defs | {G : Type u_1} → [inst : Group G] → { N // N.Normal } ≃o Con G | The normal subgroups correspond to the congruence relations on a group.
| true |
Associates.isUnit_iff_eq_one | Mathlib.Algebra.GroupWithZero.Associated | ∀ {M : Type u_1} [inst : CommMonoid M] (a : Associates M), IsUnit a ↔ a = 1 | null | true |
mul_lt_mul_of_neg_left | Mathlib.Algebra.Order.Ring.Unbundled.Basic | ∀ {R : Type u} [inst : Semiring R] [inst_1 : PartialOrder R] {a b c : R} [ExistsAddOfLE R] [PosMulStrictMono R]
[AddRightStrictMono R] [AddRightReflectLT R], b < a → c < 0 → c * a < c * b | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.