name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
List.lawfulBEq_iff | Init.Data.List.Lemmas | ∀ {α : Type u_1} [inst : BEq α], LawfulBEq (List α) ↔ LawfulBEq α | null | true |
CategoryTheory.Aut.toEnd._proof_2 | Mathlib.CategoryTheory.Endomorphism | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C} (x y : CategoryTheory.Aut X),
{ asHom := (x * y).asIso.hom } = { asHom := x.asIso.hom } * { asHom := y.asIso.hom } | null | false |
Set.uIoc_injective_left | Mathlib.Order.Interval.Set.UnorderedInterval | ∀ {α : Type u_1} [inst : LinearOrder α] (a : α), Function.Injective (Set.uIoc a) | null | true |
_private.Batteries.Data.List.Lemmas.0.List.getElem_idxOf_eq_idxOfNth_add._proof_1_2 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {x : α} [inst : BEq α] {n s : ℕ} {h : n < (List.idxsOf x [] s).length}, n < (List.idxsOf x [] s).length | null | false |
Finset.sum_smul | Mathlib.Algebra.Module.BigOperators | ∀ {ι : Type u_1} {R : Type u_5} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
{f : ι → R} {s : Finset ι} {x : M}, (∑ i ∈ s, f i) • x = ∑ i ∈ s, f i • x | null | true |
_private.Mathlib.RingTheory.RingHom.Integral.0.RingHom.isIntegral_ofLocalizationSpan._simp_1_7 | Mathlib.RingTheory.RingHom.Integral | ∀ {G : Type u_7} {H : Type u_8} {F : Type u_9} [inst : FunLike F G H] [inst_1 : Monoid G] [inst_2 : Monoid H]
[MonoidHomClass F G H] (f : F) (a : G) (n : ℕ), f a ^ n = f (a ^ n) | null | false |
_private.Mathlib.Order.RelSeries.0.LTSeries.apply_add_index_le_apply_add_index_int._proof_1_7 | Mathlib.Order.RelSeries | ∀ (p : LTSeries ℤ) (j : ℕ), j + 1 < p.length + 1 → j < p.length | null | false |
SuccAddOrder.toSuccOrder | Mathlib.Algebra.Order.SuccPred | {α : Type u_1} → {inst : Preorder α} → {inst_1 : Add α} → {inst_2 : One α} → [self : SuccAddOrder α] → SuccOrder α | null | true |
IsOfFinAddOrder.prod_iff | Mathlib.GroupTheory.OrderOfElement | ∀ {α : Type u_4} {β : Type u_5} [inst : AddMonoid α] [inst_1 : AddMonoid β] {x : α × β},
IsOfFinAddOrder x ↔ IsOfFinAddOrder x.1 ∧ IsOfFinAddOrder x.2 | null | true |
RingEquiv.toSemiRingCatIso._proof_3 | Mathlib.Algebra.Category.Ring.Basic | ∀ {R S : Type u_1} [inst : Semiring R] [inst_1 : Semiring S], RingHomClass (S ≃+* R) S R | null | false |
Profinite.NobelingProof.continuous_CC'₁ | Mathlib.Topology.Category.Profinite.Nobeling.Successor | ∀ {I : Type u} (C : Set (I → Bool)) [inst : LinearOrder I] [inst_1 : WellFoundedLT I] {o : Ordinal.{u}}
(hsC : Profinite.NobelingProof.contained C (Order.succ o)) (ho : o < Ordinal.type fun x1 x2 => x1 < x2),
Continuous (Profinite.NobelingProof.CC'₁ C hsC ho) | null | true |
Equiv.eq_conj | Mathlib.Logic.Equiv.Basic | ∀ {α : Sort u_10} {α' : Sort u_11} {β : Sort u_12} {β' : Sort u_13} (ε₁ : α ≃ α') (ε₂ : β' ≃ β) (f : α → β)
(f' : α' → β'), ⇑ε₂.symm ∘ f ∘ ⇑ε₁.symm = f' ↔ f = ⇑ε₂ ∘ f' ∘ ⇑ε₁ | null | true |
MvPowerSeries.substAlgHom_coe | Mathlib.RingTheory.MvPowerSeries.Substitution | ∀ {σ : Type u_1} {R : Type u_3} [inst : CommRing R] {τ : Type u_4} {S : Type u_5} [inst_1 : CommRing S]
[inst_2 : Algebra R S] {a : σ → MvPowerSeries τ S} (ha : MvPowerSeries.HasSubst a) (p : MvPolynomial σ R),
(MvPowerSeries.substAlgHom ha) ↑p = (MvPolynomial.aeval a) p | null | true |
EuclideanDomain.mul_div_cancel' | Mathlib.Algebra.EuclideanDomain.Basic | ∀ {R : Type u} [inst : EuclideanDomain R] {a b : R}, b ≠ 0 → b ∣ a → b * (a / b) = a | null | true |
Lean.Parser.Term.optConfig.parenthesizer | Lean.Parser.Term | Lean.PrettyPrinter.Parenthesizer | null | true |
Turing.Dir.left.sizeOf_spec | Mathlib.Computability.TuringMachine.Tape | sizeOf Turing.Dir.left = 1 | null | true |
_private.Mathlib.Data.Set.Card.0.Set.Finite.exists_injOn_of_encard_le._simp_1_12 | Mathlib.Data.Set.Card | ∀ {b a : Prop}, (∃ (_ : a), b) = (a ∧ b) | null | false |
Associates | Mathlib.Algebra.GroupWithZero.Associated | (M : Type u_2) → [Monoid M] → Type u_2 | The quotient of a monoid by the `Associated` relation. Two elements `x` and `y`
are associated iff there is a unit `u` such that `x * u = y`. There is a natural
monoid structure on `Associates M`. | true |
CommAlgCat.FiniteEtale.equivOfIsSepClosed._proof_12 | Mathlib.RingTheory.Etale.Finite | ∀ (Ω : Type u_1) [inst : Field Ω] (R : (CommAlgCat.FiniteEtale Ω)ᵒᵖ), Algebra.FormallyEtale Ω ↑(Opposite.unop R).obj | null | false |
Lean.ParametricAttribute.mk._flat_ctor | Lean.Attributes | {α : Type} →
Lean.AttributeImpl →
Lean.PersistentEnvExtension (Lean.Name × α) (Lean.Name × α) (List Lean.Name × Lean.NameMap α) →
Bool → Lean.ParametricAttribute α | null | false |
SimpleGraph.ConnectedComponent.even_card_of_isPerfectMatching | Mathlib.Combinatorics.SimpleGraph.Matching | ∀ {V : Type u_1} {G : SimpleGraph V} {M : G.Subgraph} [inst : Fintype V] [inst_1 : DecidableEq V]
[inst_2 : DecidableRel G.Adj] (c : G.ConnectedComponent), M.IsPerfectMatching → Even (Fintype.card ↑c.supp) | null | true |
MulOpposite.instInvolutiveNeg | Mathlib.Algebra.Opposites | {α : Type u_1} → [InvolutiveNeg α] → InvolutiveNeg αᵐᵒᵖ | null | true |
IsPowMul.restriction | Mathlib.Analysis.Normed.Ring.Basic | ∀ {R : Type u_5} {S : Type u_6} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] (A : Subalgebra R S)
{f : S → ℝ}, IsPowMul f → IsPowMul fun x => f ↑x | The restriction of a power-multiplicative function to a subalgebra is power-multiplicative. | true |
FiniteDimensional.basisSingleton._proof_6 | Mathlib.LinearAlgebra.FiniteDimensional.Basic | ∀ {K : Type u_1} [inst : DivisionRing K], RingHomInvPair (RingHom.id K) (RingHom.id K) | null | false |
AlgebraicGeometry.Scheme.Hom.map_appLE'_assoc | Mathlib.AlgebraicGeometry.Scheme | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) {U U' : Y.Opens} {V : X.Opens}
(e : V ≤ (TopologicalSpace.Opens.map f.base).obj U) (i : U' = U) {Z : CommRingCat}
(h : X.presheaf.obj (Opposite.op V) ⟶ Z),
CategoryTheory.CategoryStruct.comp (Y.presheaf.map (CategoryTheory.eqToHom i).op)
(CategoryTheory.Categor... | null | true |
Aesop.runTacticMAsElabM | Aesop.RuleTac.ElabRuleTerm | {α : Type} → Lean.Elab.Tactic.TacticM α → Aesop.ElabM α | null | true |
Filter.Germ.instDivisionSemiring._proof_6 | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u_2} {β : Type u_1} {φ : Ultrafilter α} [DivisionSemiring β], Nontrivial ((↑φ).Germ β) | null | false |
Cardinal.mul_natCast_le_mul_natCast._simp_1 | Mathlib.SetTheory.Cardinal.Arithmetic | ∀ {n : ℕ} {a b : Cardinal.{u_1}}, n ≠ 0 → (a * ↑n ≤ b * ↑n) = (a ≤ b) | null | false |
Mathlib.Tactic.Choose.ElimStatus.ctorIdx | Mathlib.Tactic.Choose | Mathlib.Tactic.Choose.ElimStatus → ℕ | null | false |
List.toList_mkSlice_roc | Init.Data.Slice.List.Lemmas | ∀ {α : Type u_1} {xs : List α} {lo hi : ℕ},
Std.Slice.toList (Std.Roc.Sliceable.mkSlice xs (lo<...=hi)) = List.drop (lo + 1) (List.take (hi + 1) xs) | null | true |
OrderType.lift_id | Mathlib.Order.Types.Defs | ∀ (o : OrderType.{u}), OrderType.lift.{u, u} o = o | An order type lifted to the same universe equals itself. | true |
_private.Lean.Util.OccursCheck.0.Lean.occursCheck.visit._unsafe_rec | Lean.Util.OccursCheck | {m : Type → Type} → [Monad m] → [Lean.MonadMCtx m] → Lean.MVarId → Lean.Expr → ExceptT Unit (StateT Lean.ExprSet m) Unit | null | false |
Array.pmap_ne_empty_iff | Init.Data.Array.Attach | ∀ {α : Type u_1} {β : Type u_2} {P : α → Prop} (f : (a : α) → P a → β) {xs : Array α} (H : ∀ a ∈ xs, P a),
Array.pmap f xs H ≠ #[] ↔ xs ≠ #[] | null | true |
PointedCone.dual_le_dual | Mathlib.Geometry.Convex.Cone.Dual | ∀ {R : Type u_1} [inst : CommSemiring R] [inst_1 : PartialOrder R] [inst_2 : IsOrderedRing R] {M : Type u_2}
[inst_3 : AddCommMonoid M] [inst_4 : Module R M] {N : Type u_3} [inst_5 : AddCommMonoid N] [inst_6 : Module R N]
{p : M →ₗ[R] N →ₗ[R] R} {s t : Set M}, t ⊆ s → PointedCone.dual p s ≤ PointedCone.dual p t | **Alias** of `PointedCone.dual_anti`. | true |
_private.Mathlib.Combinatorics.SimpleGraph.Sum.0.SimpleGraph.edgeSetSumEquiv.match_1.eq_2 | Mathlib.Combinatorics.SimpleGraph.Sum | ∀ {V : Type u_1} {W : Type u_2} {G : SimpleGraph V} {H : SimpleGraph W}
(motive : (x x_1 : V ⊕ W) → (G ⊕g H).Adj x x_1 → Sort u_3) (u v : W) (h : (G ⊕g H).Adj (Sum.inr u) (Sum.inr v))
(h_1 : (u v : V) → (h : (G ⊕g H).Adj (Sum.inl u) (Sum.inl v)) → motive (Sum.inl u) (Sum.inl v) h)
(h_2 : (u v : W) → (h : (G ⊕g H)... | null | true |
Std.ExtTreeMap.minKey!_insertIfNew_le_self | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α β cmp} [inst : Std.TransCmp cmp]
[inst_1 : Inhabited α] {k : α} {v : β}, (cmp (t.insertIfNew k v).minKey! k).isLE = true | null | true |
CategoryTheory.Limits.HasWidePushout.eq_1 | Mathlib.CategoryTheory.Limits.Shapes.WidePullbacks | ∀ {J : Type w} {C : Type u} [inst : CategoryTheory.Category.{v, u} C] (B : C) (objs : J → C)
(arrows : (j : J) → B ⟶ objs j),
CategoryTheory.Limits.HasWidePushout B objs arrows =
CategoryTheory.Limits.HasColimit (CategoryTheory.Limits.WidePushoutShape.wideSpan B objs arrows) | null | true |
TensorProduct.instInhabited | Mathlib.LinearAlgebra.TensorProduct.Defs | {R : Type u_1} →
[inst : CommSemiring R] →
(M : Type u_5) →
(N : Type u_6) →
[inst_1 : AddCommMonoid M] →
[inst_2 : AddCommMonoid N] → [inst_3 : Module R M] → [inst_4 : Module R N] → Inhabited (TensorProduct R M N) | null | true |
Mathlib.Tactic.Determinant.certIterStepEntry | Mathlib.Tactic.Determinant.Bird.Cert | {u : Lean.Level} →
{α : Q(Type u)} →
{rα : Q(CommRing «$α»)} → ℕ → ℕ → ℕ → Mathlib.Tactic.Determinant.CertM rα (Mathlib.Tactic.Determinant.Cert rα) | Certify an entry of `(BirdDet.stepEntry n A)^[t] (BirdDet.get n A)`. | true |
MulRingNorm._sizeOf_1 | Mathlib.Analysis.Normed.Unbundled.RingSeminorm | {R : Type u_2} → {inst : NonAssocRing R} → [SizeOf R] → MulRingNorm R → ℕ | null | false |
Aesop.Index.mk.inj | Aesop.Index | ∀ {α : Type} {byTarget byHyp : Lean.Meta.DiscrTree (Aesop.Rule α)} {unindexed : Lean.PHashSet (Aesop.Rule α)}
{byTarget_1 byHyp_1 : Lean.Meta.DiscrTree (Aesop.Rule α)} {unindexed_1 : Lean.PHashSet (Aesop.Rule α)},
{ byTarget := byTarget, byHyp := byHyp, unindexed := unindexed } =
{ byTarget := byTarget_1, byH... | null | true |
Nat.digits_ne_nil_iff_ne_zero | Mathlib.Data.Nat.Digits.Defs | ∀ {b n : ℕ}, b.digits n ≠ [] ↔ n ≠ 0 | null | true |
ContinuousLinearMap.opNorm_add_le | Mathlib.Analysis.Normed.Operator.Basic | ∀ {𝕜 : Type u_1} {𝕜₂ : Type u_2} {E : Type u_4} {F : Type u_5} [inst : SeminormedAddCommGroup E]
[inst_1 : SeminormedAddCommGroup F] [inst_2 : NontriviallyNormedField 𝕜] [inst_3 : NontriviallyNormedField 𝕜₂]
[inst_4 : NormedSpace 𝕜 E] [inst_5 : NormedSpace 𝕜₂ F] {σ₁₂ : 𝕜 →+* 𝕜₂} [RingHomIsometric σ₁₂] (f g ... | The operator norm satisfies the triangle inequality. | true |
SimpleGraph.ball_two | Mathlib.Combinatorics.SimpleGraph.Metric | ∀ {V : Type u_1} {G : SimpleGraph V} {c : V}, G.ball c 2 = insert c (G.neighborSet c) | The ball of radius two consists of the center and its neighbors. | true |
hasFPowerSeriesAt_log_one_add | Mathlib.Analysis.SpecialFunctions.Complex.Analytic | HasFPowerSeriesAt (fun x => Real.log (1 + x)) (FormalMultilinearSeries.ofScalars ℝ fun n => -(-1) ^ n / ↑n) 0 | null | true |
Finset.nsmul_right_monotone | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : AddMonoid α] {s : Finset α}, 0 ∈ s → Monotone fun x => x • s | null | true |
IsLocalMin.add | Mathlib.Topology.Order.LocalExtr | ∀ {α : Type u} {β : Type v} [inst : TopologicalSpace α] [inst_1 : AddCommMonoid β] [inst_2 : PartialOrder β]
[IsOrderedAddMonoid β] {f g : α → β} {a : α}, IsLocalMin f a → IsLocalMin g a → IsLocalMin (fun x => f x + g x) a | null | true |
Aesop.Script.TacticBuilder.simpAllOrSimpAtStarOnly | Aesop.Script.SpecificTactics | Bool → Lean.MVarId → Option Lean.Term → Lean.Meta.Simp.UsedSimps → Aesop.Script.TacticBuilder | null | true |
LinearMap.detAux.congr_simp | Mathlib.LinearAlgebra.Determinant | ∀ {M : Type u_7} [inst : AddCommGroup M] {ι : Type u_8} {inst_1 : DecidableEq ι} [inst_2 : DecidableEq ι]
[inst_3 : Fintype ι] {A : Type u_9} [inst_4 : CommRing A] [inst_5 : Module A M] (a a_1 : Trunc (Module.Basis ι A M)),
a = a_1 → LinearMap.detAux a = LinearMap.detAux a_1 | null | true |
OrderHom.le_prevFixed_iff._simp_1 | Mathlib.Order.FixedPoints | ∀ {α : Type u} [inst : CompleteLattice α] (f : α →o α) {x : α} (hx : f x ≤ x) {y : ↑(Function.fixedPoints ⇑f)},
(y ≤ f.prevFixed x hx) = (↑y ≤ x) | null | false |
CategoryTheory.SmallObject.SuccStruct.Iteration.mkOfLimit.inductiveSystem._proof_2 | Mathlib.CategoryTheory.SmallObject.Iteration.Nonempty | ∀ {J : Type u_1} [inst : LinearOrder J] {j : J} {i₁ : ↑(Set.Iio j)}, ↑i₁ ≤ ↑i₁ | null | false |
cmp_sub_zero | Mathlib.Algebra.Order.Group.Unbundled.Basic | ∀ {α : Type u} [inst : AddGroup α] [inst_1 : LinearOrder α] [AddRightMono α] (a b : α), cmp (a - b) 0 = cmp a b | null | true |
CategoryTheory.Pseudofunctor.DescentData'._sizeOf_1 | Mathlib.CategoryTheory.Sites.Descent.DescentDataPrime | {C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{F : CategoryTheory.Pseudofunctor (CategoryTheory.LocallyDiscrete Cᵒᵖ) CategoryTheory.Cat} →
{ι : Type t} →
{S : C} →
{X : ι → C} →
{f : (i : ι) → X i ⟶ S} →
{sq : (i j : ι) → CategoryTheory.Limits.ChosenP... | null | false |
Module.ker_algebraMap_end | Mathlib.Algebra.Algebra.Basic | ∀ (K : Type u) (V : Type v) [inst : Semifield K] [inst_1 : AddCommMonoid V] [inst_2 : Module K V] (a : K),
a ≠ 0 → LinearMap.ker ((algebraMap K (Module.End K V)) a) = ⊥ | null | true |
_private.Init.Data.Range.Polymorphic.RangeIterator.0.Std.Rxc.Iterator.instIteratorLoop.loop.match_3.eq_1 | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u_1} (γ : Type u_1) (Pl : α → γ → ForInStep γ → Prop) (next : α) (acc : γ)
(motive : Subtype (Pl next acc) → Sort u_2) (acc' : γ) (h' : Pl next acc (ForInStep.yield acc'))
(h_1 : (acc' : γ) → (h' : Pl next acc (ForInStep.yield acc')) → motive ⟨ForInStep.yield acc', h'⟩)
(h_2 : (acc' : γ) → (property :... | null | true |
LSeries_neg | Mathlib.NumberTheory.LSeries.Linearity | ∀ (f : ℕ → ℂ) (s : ℂ), LSeries (-f) s = -LSeries f s | null | true |
BoolAlg.dual | Mathlib.Order.Category.BoolAlg | CategoryTheory.Functor BoolAlg BoolAlg | `OrderDual` as a functor. | true |
_private.Mathlib.Topology.Instances.ENNReal.Lemmas.0.tendsto_iff_edist_tendsto_0._simp_1_1 | Mathlib.Topology.Instances.ENNReal.Lemmas | ∀ {α : Type u} [inst : EDist α] {x y : α} {ε : ENNReal}, (y ∈ Metric.eball x ε) = (edist y x < ε) | null | false |
Lean.Meta.Grind.Arith.CommRing.State | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Type | State for all `CommRing` types detected by `grind`. | true |
_private.Std.Time.Zoned.ZoneRules.0.Std.Time.TimeZone.RecurringRule.transitionUtcSeconds | Std.Time.Zoned.ZoneRules | Std.Time.TimeZone.TransitionRule → Std.Time.Year.Offset → Std.Time.TimeZone.Offset → Std.Time.Second.Offset | null | true |
Array.attachWith_map.match_1 | Init.Data.Array.Attach | {α : Type u_1} →
{β : Type u_2} →
{f : α → β} →
{P : β → Prop} →
(motive : { x // (P ∘ f) x } → Sort u_3) →
(x : { x // (P ∘ f) x }) → ((x : α) → (h : (P ∘ f) x) → motive ⟨x, h⟩) → motive x | null | false |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.evalFunCases | Lean.Elab.Tactic.Induction | Lean.Elab.Tactic.Tactic | null | true |
OrderDual.instIsLowerSet | Mathlib.Topology.Order.UpperLowerSetTopology | ∀ {α : Type u_1} [inst : Preorder α] [inst_1 : TopologicalSpace α] [Topology.IsUpperSet α], Topology.IsLowerSet αᵒᵈ | null | true |
Std.DTreeMap.Internal.Impl.maxEntry! | Std.Data.DTreeMap.Internal.Queries | {α : Type u} → {β : α → Type v} → [Inhabited ((a : α) × β a)] → Std.DTreeMap.Internal.Impl α β → (a : α) × β a | Implementation detail of the tree map | true |
SSet.horn.IsCompatible.liftOfKanComplex.congr_simp | Mathlib.AlgebraicTopology.SimplicialSet.KanComplex | ∀ {X : SSet} {n : ℕ} {i : Fin (n + 2)} {f f_1 : (j : Fin (n + 2)) → j ≠ i → (SSet.stdSimplex.obj { len := n } ⟶ X)}
(e_f : f = f_1) [inst : X.KanComplex] (hf : SSet.horn.IsCompatible f), hf.liftOfKanComplex = ⋯.liftOfKanComplex | null | true |
ContDiffOn.div_const | Mathlib.Analysis.Calculus.ContDiff.Operations | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {𝕜' : Type u_6} [inst_3 : NormedField 𝕜'] [inst_4 : NormedAlgebra 𝕜 𝕜']
{f : E → 𝕜'} {n : WithTop ℕ∞}, ContDiffOn 𝕜 n f s → ∀ (c : 𝕜'), ContDiffOn 𝕜 n (fun x => f x / c... | null | true |
CategoryTheory.ShortComplex.QuasiIso.mk | Mathlib.Algebra.Homology.ShortComplex.QuasiIso | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} [inst_2 : S₁.HasHomology] [inst_3 : S₂.HasHomology] {φ : S₁ ⟶ S₂},
CategoryTheory.IsIso (CategoryTheory.ShortComplex.homologyMap φ) → CategoryTheory.ShortComplex... | null | true |
Fin.findSome?_eq_findSome?_finRange | Batteries.Data.Fin.Lemmas | ∀ {n : ℕ} {α : Type u_1} (f : Fin n → Option α), Fin.findSome? f = List.findSome? f (List.finRange n) | null | true |
IsLocalization.toInvSubmonoid._proof_1 | Mathlib.RingTheory.Localization.InvSubmonoid | ∀ {R : Type u_1} [inst : CommRing R] (S : Type u_2) [inst_1 : CommRing S], MonoidHomClass (R →+* S) R S | null | false |
_private.Mathlib.Tactic.Linarith.Preprocessing.0.Mathlib.Tactic.Linarith.splitConjunctions.aux._sparseCasesOn_1 | Mathlib.Tactic.Linarith.Preprocessing | {motive : Lean.Name → Sort u} →
(t : Lean.Name) →
((pre : Lean.Name) → (str : String) → motive (pre.str str)) → (Nat.hasNotBit 2 t.ctorIdx → motive t) → motive t | null | false |
CategoryTheory.ShortComplex.LeftHomologyData.cyclesIso_inv_comp_iCycles_assoc | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S : CategoryTheory.ShortComplex C} (h : S.LeftHomologyData) [inst_2 : S.HasLeftHomology] {Z : C} (h_1 : S.X₂ ⟶ Z),
CategoryTheory.CategoryStruct.comp h.cyclesIso.inv (CategoryTheory.CategoryStruct.com... | null | true |
Std.CancellationReason.cancel.elim | Std.Sync.CancellationToken | {motive : Std.CancellationReason → Sort u} →
(t : Std.CancellationReason) → t.ctorIdx = 2 → motive Std.CancellationReason.cancel → motive t | null | false |
_private.Mathlib.MeasureTheory.Measure.AEDisjoint.0.MeasureTheory.exists_null_pairwise_disjoint_sdiff._simp_1_2 | Mathlib.MeasureTheory.Measure.AEDisjoint | ∀ {α : Type u} {s t : Set α} (x : α), (x ∈ s \ t) = (x ∈ s ∧ x ∉ t) | null | false |
FirstOrder.Language.ElementarilyEquivalent | Mathlib.ModelTheory.Semantics | (L : FirstOrder.Language) → (M : Type w) → (N : Type u_1) → [L.Structure M] → [L.Structure N] → Prop | Two structures are elementarily equivalent when they satisfy the same sentences. | true |
Lean.Compiler.LCNF.LCtx.mk | Lean.Compiler.LCNF.LCtx | Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.pure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.Param Lean.Compiler.LCNF.Purity.impure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.LetDecl Lean.Compiler.LCNF.Purity.pure) →
Std.HashMap Lean.FVarId (Lean.Compiler.LCNF.LetDecl ... | null | true |
MeasureTheory.Measure.measure_isAddInvariant_eq_smul_of_isCompact_closure_of_innerRegularCompactLTTop | 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 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_8 : μ'.IsAddLe... | If an invariant measure is inner regular, then it gives the same mass to measurable sets with
compact closure as any other invariant measure, up to the scalar `addHaarScalarFactor μ' μ`.
Auxiliary lemma in the proof of the more general
`measure_isAddInvariant_eq_smul_of_isCompact_closure`, which works for any set with... | true |
Polynomial.mem_degreeLT | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u} [inst : Semiring R] {n : ℕ} {f : Polynomial R}, f ∈ Polynomial.degreeLT R n ↔ f.degree < ↑n | null | true |
CategoryTheory.MonoidalCategory.prodMonoidal.match_1 | Mathlib.CategoryTheory.Monoidal.Category | (C₁ : Type u_1) →
(C₂ : Type u_2) → (motive : C₁ × C₂ → Sort u_3) → (x : C₁ × C₂) → ((X₁ : C₁) → (X₂ : C₂) → motive (X₁, X₂)) → motive x | null | false |
Set.ncard_image_le._auto_1 | Mathlib.Data.Set.Card | Lean.Syntax | null | false |
Std.DHashMap.Internal.Raw₀.interSmallerFn | Std.Data.DHashMap.Internal.Defs | {α : Type u} →
{β : α → Type v} →
[BEq α] →
[Hashable α] →
Std.DHashMap.Internal.Raw₀ α β → Std.DHashMap.Internal.Raw₀ α β → α → Std.DHashMap.Internal.Raw₀ α β | Internal implementation detail of the hash map | true |
Lean.Lsp.CompletionItem._sizeOf_1 | Lean.Data.Lsp.LanguageFeatures | Lean.Lsp.CompletionItem → ℕ | null | false |
ZeroHom.recOn | Mathlib.Algebra.Group.Hom.Defs | {M : Type u_10} →
{N : Type u_11} →
[inst : Zero M] →
[inst_1 : Zero N] →
{motive : ZeroHom M N → Sort u} →
(t : ZeroHom M N) →
((toFun : M → N) → (map_zero' : toFun 0 = 0) → motive { toFun := toFun, map_zero' := map_zero' }) → motive t | null | false |
Antitone.tendstoLocallyUniformly_of_forall_tendsto | Mathlib.Topology.UniformSpace.Dini | ∀ {ι : Type u_1} {α : Type u_2} {G : Type u_3} [inst : Preorder ι] [inst_1 : TopologicalSpace α]
[inst_2 : NormedAddCommGroup G] [inst_3 : Lattice G] [HasSolidNorm G] [IsOrderedAddMonoid G] {F : ι → α → G}
{f : α → G},
(∀ (i : ι), Continuous (F i)) →
Antitone F →
Continuous f →
(∀ (x : α), Filte... | **Dini's theorem**: if `F n` is a monotone decreasing collection of continuous functions on a
converging pointwise to a continuous function `f`, then `F n` converges locally uniformly to `f`. | true |
Measurable.fst | Mathlib.MeasureTheory.MeasurableSpace.Constructions | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {m : MeasurableSpace α} {mβ : MeasurableSpace β} {mγ : MeasurableSpace γ}
{f : α → β × γ}, Measurable f → Measurable fun a => (f a).1 | null | true |
Language.reverse_add | Mathlib.Computability.Language | ∀ {α : Type u_1} (l m : Language α), (l + m).reverse = l.reverse + m.reverse | null | true |
Lean.Server.References.recOn | Lean.Server.References | {motive : Lean.Server.References → Sort u} →
(t : Lean.Server.References) →
((ileans : Lean.Server.ILeanMap) →
(workers : Lean.Server.WorkerRefMap) → motive { ileans := ileans, workers := workers }) →
motive t | null | false |
CategoryTheory.Functor.quotientCompMapHomotopyCategoryPlusIso | Mathlib.Algebra.Homology.HomotopyCategory.Plus | {C : Type u_1} →
{D : Type u_2} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Category.{v_2, u_2} D] →
[inst_2 : CategoryTheory.Preadditive C] →
[inst_3 : CategoryTheory.Preadditive D] →
(F : CategoryTheory.Functor C D) →
[inst_4 : F.A... | The functor `F.mapHomotopyCategoryPlus : HomotopyCategory.Plus C ⥤ HomotopyCategory.Plus D`
is induced by `F.mapCochainComplexPlus`. | true |
Std.Rxc.Iterator.Monadic.isPlausibleIndirectOutput_iff | Init.Data.Range.Polymorphic.RangeIterator | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [inst_1 : LE α] [inst_2 : DecidableLE α]
[Std.PRange.LawfulUpwardEnumerableLE α] [Std.PRange.LawfulUpwardEnumerable α] {it : Std.IterM Id α} {out : α},
it.IsPlausibleIndirectOutput out ↔
∃ n, (it.internalState.next.bind fun x => Std.PRange.succMany? n x) = s... | null | true |
Finsupp.restrictSupportEquiv._proof_2 | Mathlib.Data.Finsupp.Basic | ∀ {α : Type u_1} (s : Set α) (M : Type u_2) [inst : AddCommMonoid M] (f : { f // ↑f.support ⊆ s }),
↑(Finsupp.subtypeDomain (fun x => x ∈ s) ↑f).extendDomain.support ⊆ {x | x ∈ s} | null | false |
ContDiffMapSupportedIn.noConfusion | Mathlib.Analysis.Distribution.ContDiffMapSupportedIn | {P : Sort u} →
{E : Type u_2} →
{F : Type u_3} →
{inst : NormedAddCommGroup E} →
{inst_1 : NormedSpace ℝ E} →
{inst_2 : NormedAddCommGroup F} →
{inst_3 : NormedSpace ℝ F} →
{n : ℕ∞} →
{K : TopologicalSpace.Compacts E} →
{t : ContD... | null | false |
CharP.ringChar_ne_one | Mathlib.Algebra.CharP.Defs | ∀ {R : Type u_1} [inst : NonAssocSemiring R] [Nontrivial R], ringChar R ≠ 1 | null | true |
CochainComplex.HomComplex.Cocycle.toSingleMk_coe | Mathlib.Algebra.Homology.HomotopyCategory.HomComplexSingle | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.Limits.HasZeroObject C] {X : C} {K : CochainComplex C ℤ} {p q : ℤ} (f : K.X p ⟶ X) {n : ℤ}
(h : p + n = q) (p' : ℤ) (hp' : p' + 1 = p) (hf : CategoryTheory.CategoryStruct.comp (K.d p' p) f = 0),... | null | true |
CategoryTheory.nerve.homEquiv_edgeMk_map_nerveMap | Mathlib.AlgebraicTopology.SimplicialSet.Nerve | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {D : Type u} [inst_1 : CategoryTheory.Category.{v, u} D]
{x y : C} (f : x ⟶ y) (F : CategoryTheory.Functor C D),
CategoryTheory.nerve.homEquiv ((CategoryTheory.nerve.edgeMk f).map (CategoryTheory.nerveMap F)) = F.map f | null | true |
TensorProduct.instNormedAddCommGroup._proof_6 | Mathlib.Analysis.InnerProductSpace.TensorProduct | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : RCLike 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : InnerProductSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : InnerProductSpace 𝕜 F]
(x x_1 : TensorProduct 𝕜 E F) (x_2 : 𝕜),
(((TensorProduct.lift (TensorProduct.mapBilinear (RingHom.id 𝕜) E F 𝕜 ... | null | false |
Std.Iterators.Types.Zip.instFinitenessRelation₁ | Std.Data.Iterators.Combinators.Monadic.Zip | {m : Type w → Type w'} →
{α₁ β₁ : Type w} →
[inst : Std.Iterator α₁ m β₁] →
{α₂ β₂ : Type w} →
[inst_1 : Std.Iterator α₂ m β₂] →
[inst_2 : Monad m] →
[Std.Iterators.Finite α₁ m] →
[Std.Iterators.Productive α₂ m] → Std.Iterators.FinitenessRelation (Std.Iterators.Ty... | null | true |
QuadraticModuleCat.forget₂_map_associator_inv | Mathlib.LinearAlgebra.QuadraticForm.QuadraticModuleCat.Monoidal | ∀ {R : Type u} [inst : CommRing R] [inst_1 : Invertible 2] (X Y Z : QuadraticModuleCat R),
(CategoryTheory.forget₂ (QuadraticModuleCat R) (ModuleCat R)).map
(CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv =
(CategoryTheory.MonoidalCategoryStruct.associator X.toModuleCat Y.toModuleCat Z.toModule... | null | true |
_private.Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure.0.AlgebraicClosure.isAlgebraic.match_1 | Mathlib.FieldTheory.IsAlgClosed.AlgebraicClosure | ∀ (k : Type u_1) [inst : Field k] (z : AlgebraicClosure k)
(motive : (∃ a, (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) a = z) → Prop)
(x : ∃ a, (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) a = z),
(∀ (p : MvPolynomial (AlgebraicClosure.Vars k) k) (hp : (Ideal.Quotient.mk (AlgebraicClosure.maxIdeal k)) ... | null | false |
BitVec.reduceEq | Lean.Meta.Tactic.Simp.BuiltinSimprocs.BitVec | Lean.Meta.Simp.Simproc | Simplification procedure for `=` on `BitVec`s. | true |
«_aux_ImportGraph_Tools_ImportDiff___elabRules_command#import_diff__1» | ImportGraph.Tools.ImportDiff | Lean.Elab.Command.CommandElab | `#import_diff foo bar ...` computes the new transitive imports that are added to a given file when
modules `foo, bar, ...` are added to the set of imports of the file. More precisely, it computes the
import diff between when `foo, bar, ...` are added to the imports and when `foo, bar, ...` are removed
from the imports.... | false |
Complex.norm_exp_ofReal_mul_I | Mathlib.Analysis.Complex.Trigonometric | ∀ (x : ℝ), ‖Complex.exp (↑x * Complex.I)‖ = 1 | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.