name
stringlengths 2
347
| module
stringlengths 6
90
| type
stringlengths 1
5.42M
|
|---|---|---|
AddAction.prodOfVAddCommClass.eq_1
|
Mathlib.Algebra.Group.Action.Prod
|
∀ (M : Type u_1) (N : Type u_2) (α : Type u_5) [inst : AddMonoid M] [inst_1 : AddMonoid N] [inst_2 : AddAction M α]
[inst_3 : AddAction N α] [inst_4 : VAddCommClass M N α],
AddAction.prodOfVAddCommClass M N α = { vadd := fun mn a => mn.1 +ᵥ mn.2 +ᵥ a, add_vadd := ⋯, zero_vadd := ⋯ }
|
Finpartition.empty._proof_1
|
Mathlib.Order.Partition.Finpartition
|
∀ (α : Type u_1) [inst : Lattice α] [inst_1 : OrderBot α], ∅.SupIndep id
|
IsFractionRing.ringEquivOfRingEquiv_algebraMap
|
Mathlib.RingTheory.Localization.FractionRing
|
∀ {A : Type u_8} {K : Type u_9} {B : Type u_10} {L : Type u_11} [inst : CommRing A] [inst_1 : CommRing B]
[inst_2 : CommRing K] [inst_3 : CommRing L] [inst_4 : Algebra A K] [inst_5 : IsFractionRing A K]
[inst_6 : Algebra B L] [inst_7 : IsFractionRing B L] (h : A ≃+* B) (a : A),
(IsFractionRing.ringEquivOfRingEquiv h) ((algebraMap A K) a) = (algebraMap B L) (h a)
|
Matrix.nonAssocSemiring
|
Mathlib.Data.Matrix.Mul
|
{n : Type u_3} → {α : Type v} → [NonAssocSemiring α] → [Fintype n] → [DecidableEq n] → NonAssocSemiring (Matrix n n α)
|
_private.Mathlib.Topology.Separation.Hausdorff.0.t2_iff_nhds._simp_1_4
|
Mathlib.Topology.Separation.Hausdorff
|
∀ {a b : Prop}, (¬a → b) = (¬b → a)
|
_private.Mathlib.Tactic.GCongr.Core.0.Mathlib.Tactic.GCongr.initFn._proof_8._@.Mathlib.Tactic.GCongr.Core.2213018204._hygCtx._hyg.2
|
Mathlib.Tactic.GCongr.Core
|
∀ (xs : Array Lean.Expr) (i : ℕ), i + 1 ≤ xs.size → i < xs.size
|
Lean.Elab.Tactic.BVDecide.LRAT.trim.M.markUsed
|
Lean.Elab.Tactic.BVDecide.LRAT.Trim
|
ℕ → Lean.Elab.Tactic.BVDecide.LRAT.trim.M Unit
|
Lean.Lsp.instToJsonCompletionClientCapabilities.toJson
|
Lean.Data.Lsp.Capabilities
|
Lean.Lsp.CompletionClientCapabilities → Lean.Json
|
measurableSet_le'
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Order
|
∀ {α : Type u_1} [inst : TopologicalSpace α] {mα : MeasurableSpace α} [OpensMeasurableSpace α] [inst_2 : PartialOrder α]
[OrderClosedTopology α] [SecondCountableTopology α], MeasurableSet {p | p.1 ≤ p.2}
|
_private.Mathlib.MeasureTheory.Measure.Prokhorov.0.isCompact_setOf_finiteMeasure_mass_le_compl_isCompact_le._simp_1_6
|
Mathlib.MeasureTheory.Measure.Prokhorov
|
∀ {a : ℝ} {b : NNReal}, (ENNReal.ofReal a ≤ ↑b) = (a ≤ ↑b)
|
Std.TreeMap.Raw.Equiv.getElem_eq
|
Std.Data.TreeMap.Raw.Lemmas
|
∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.TreeMap.Raw α β cmp} [inst : Std.TransCmp cmp] {k : α}
{hk : k ∈ t₁} (h₁ : t₁.WF) (h₂ : t₂.WF) (h : t₁.Equiv t₂), t₁[k] = t₂[k]
|
CategoryTheory.SmallObject.functorMapSrc._proof_1
|
Mathlib.CategoryTheory.SmallObject.Construction
|
∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {I : Type u_3} {A B : I → C} (f : (i : I) → A i ⟶ B i)
{S T X Y : C} {πX : X ⟶ S} {πY : Y ⟶ T} (τ : CategoryTheory.Arrow.mk πX ⟶ CategoryTheory.Arrow.mk πY)
(x : CategoryTheory.SmallObject.FunctorObjIndex f πX),
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp x.t τ.left) πY =
CategoryTheory.CategoryStruct.comp (f x.i) (CategoryTheory.CategoryStruct.comp x.b τ.right)
|
dif_eq_if
|
Init.ByCases
|
∀ (c : Prop) {h : Decidable c} {α : Sort u} (t e : α), (if x : c then t else e) = if c then t else e
|
List.forall_getElem
|
Init.Data.List.Lemmas
|
∀ {α : Type u_1} {l : List α} {p : α → Prop}, (∀ (i : ℕ) (h : i < l.length), p l[i]) ↔ ∀ a ∈ l, p a
|
Std.HashSet.Raw.get?_union
|
Std.Data.HashSet.RawLemmas
|
∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.HashSet.Raw α} [EquivBEq α] [LawfulHashable α],
m₁.WF → m₂.WF → ∀ {k : α}, (m₁ ∪ m₂).get? k = (m₂.get? k).or (m₁.get? k)
|
List.mkSlice_ric_eq_mkSlice_rio
|
Init.Data.Slice.List.Lemmas
|
∀ {α : Type u_1} {xs : List α} {hi : ℕ},
(Std.Ric.Sliceable.mkSlice xs *...=hi) = Std.Rio.Sliceable.mkSlice xs *...hi + 1
|
AddCommGrpCat.Hom.hom.eq_1
|
Mathlib.Algebra.Category.Grp.Basic
|
∀ {X Y : AddCommGrpCat} (f : X.Hom Y), f.hom = CategoryTheory.ConcreteCategory.hom f
|
Lean.Data.AC.EvalInformation.arbitrary
|
Init.Data.AC
|
{α : Sort u} → {β : Sort v} → [self : Lean.Data.AC.EvalInformation α β] → α → β
|
_private.Init.PropLemmas.0.and_right_comm.match_1_1
|
Init.PropLemmas
|
∀ {a b c : Prop} (motive : (a ∧ b) ∧ c → Prop) (x : (a ∧ b) ∧ c), (∀ (ha : a) (hb : b) (hc : c), motive ⋯) → motive x
|
CommRingCat.Colimits.Prequotient.recOn
|
Mathlib.Algebra.Category.Ring.Colimits
|
{J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
{F : CategoryTheory.Functor J CommRingCat} →
{motive : CommRingCat.Colimits.Prequotient F → Sort u} →
(t : CommRingCat.Colimits.Prequotient F) →
((j : J) → (x : ↑(F.obj j)) → motive (CommRingCat.Colimits.Prequotient.of j x)) →
motive CommRingCat.Colimits.Prequotient.zero →
motive CommRingCat.Colimits.Prequotient.one →
((a : CommRingCat.Colimits.Prequotient F) → motive a → motive a.neg) →
((a a_1 : CommRingCat.Colimits.Prequotient F) → motive a → motive a_1 → motive (a.add a_1)) →
((a a_1 : CommRingCat.Colimits.Prequotient F) → motive a → motive a_1 → motive (a.mul a_1)) →
motive t
|
ZNum.zero.sizeOf_spec
|
Mathlib.Data.Num.Basic
|
sizeOf ZNum.zero = 1
|
Filter.Germ.instAddMonoidWithOne._proof_4
|
Mathlib.Order.Filter.Germ.Basic
|
∀ {α : Type u_2} {l : Filter α} {M : Type u_1} [inst : AddMonoidWithOne M] (x : ℕ), ↑↑(x + 1) = ↑fun x_1 => ↑x x_1 + 1
|
Pi.borelSpace
|
Mathlib.MeasureTheory.Constructions.BorelSpace.Basic
|
∀ {ι : Type u_6} {X : ι → Type u_7} [Countable ι] [inst : (i : ι) → TopologicalSpace (X i)]
[inst_1 : (i : ι) → MeasurableSpace (X i)] [∀ (i : ι), SecondCountableTopology (X i)] [∀ (i : ι), BorelSpace (X i)],
BorelSpace ((i : ι) → X i)
|
_private.Batteries.Data.RBMap.WF.0.Batteries.RBNode.Balanced.reverse.match_1_1
|
Batteries.Data.RBMap.WF
|
∀ {α : Type u_1} (motive : (n : ℕ) → (c : Batteries.RBColor) → (t : Batteries.RBNode α) → t.Balanced c n → Prop) (n : ℕ)
(c : Batteries.RBColor) (t : Batteries.RBNode α) (x : t.Balanced c n),
(∀ (a : Unit), motive 0 Batteries.RBColor.black Batteries.RBNode.nil ⋯) →
(∀ (x : Batteries.RBNode α) (c₁ : Batteries.RBColor) (n : ℕ) (y : Batteries.RBNode α) (c₂ : Batteries.RBColor)
(v : α) (hl : x.Balanced c₁ n) (hr : y.Balanced c₂ n),
motive (n + 1) Batteries.RBColor.black (Batteries.RBNode.node Batteries.RBColor.black x v y) ⋯) →
(∀ (n : ℕ) (x y : Batteries.RBNode α) (v : α) (hl : x.Balanced Batteries.RBColor.black n)
(hr : y.Balanced Batteries.RBColor.black n),
motive n Batteries.RBColor.red (Batteries.RBNode.node Batteries.RBColor.red x v y) ⋯) →
motive n c t x
|
_private.Mathlib.FieldTheory.IntermediateField.Adjoin.Basic.0.IntermediateField.exists_finset_of_mem_adjoin._simp_1_1
|
Mathlib.FieldTheory.IntermediateField.Adjoin.Basic
|
∀ {α : Type u_1} [inst : CompleteLattice α] {ι : Type u_8} (s : Set ι) (f : ι → α), ⨆ t ∈ s, f t = ⨆ i, f ↑i
|
ENorm
|
Mathlib.Analysis.Normed.Group.Basic
|
Type u_8 → Type u_8
|
MvPowerSeries.hasSum_eval₂
|
Mathlib.RingTheory.MvPowerSeries.Evaluation
|
∀ {σ : Type u_1} {R : Type u_2} [inst : CommRing R] [inst_1 : UniformSpace R] {S : Type u_3} [inst_2 : CommRing S]
[inst_3 : UniformSpace S] {φ : R →+* S} {a : σ → S} [IsTopologicalSemiring R] [IsUniformAddGroup R]
[IsUniformAddGroup S] [CompleteSpace S] [T2Space S] [IsTopologicalRing S] [IsLinearTopology S S],
Continuous ⇑φ →
MvPowerSeries.HasEval a →
∀ (f : MvPowerSeries σ R),
HasSum (fun d => φ ((MvPowerSeries.coeff d) f) * d.prod fun s e => a s ^ e) (MvPowerSeries.eval₂ φ a f)
|
Lean.Meta.InductionSubgoal.mk
|
Lean.Meta.Tactic.Induction
|
Lean.MVarId → Array Lean.Expr → Lean.Meta.FVarSubst → Lean.Meta.InductionSubgoal
|
_private.Lean.Server.CodeActions.Basic.0.Lean.Server.evalCodeActionProviderUnsafe
|
Lean.Server.CodeActions.Basic
|
{M : Type → Type} →
[Lean.MonadEnv M] →
[Lean.MonadOptions M] → [Lean.MonadError M] → [Monad M] → Lean.Name → M Lean.Server.CodeActionProvider
|
_private.Init.Data.Range.Polymorphic.Iterators.0.Std.Rio.Internal.isPlausibleIndirectOutput_iter_iff._simp_1_1
|
Init.Data.Range.Polymorphic.Iterators
|
∀ {α : Type u} {inst : Std.PRange.UpwardEnumerable α} {inst_1 : LT α} [self : Std.PRange.LawfulUpwardEnumerableLT α]
(a b : α), (a < b) = Std.PRange.UpwardEnumerable.LT a b
|
Subalgebra.LinearDisjoint.rank_inf_eq_one_of_commute_of_flat_right_of_inj
|
Mathlib.RingTheory.LinearDisjoint
|
∀ {R : Type u} {S : Type v} [inst : CommRing R] [inst_1 : Ring S] [inst_2 : Algebra R S] {A B : Subalgebra R S},
A.LinearDisjoint B →
∀ [Module.Flat R ↥B],
(∀ (a b : ↥(A ⊓ B)), Commute ↑a ↑b) → Function.Injective ⇑(algebraMap R S) → Module.rank R ↥(A ⊓ B) = 1
|
Subalgebra.toSubmoduleEquiv
|
Mathlib.Algebra.Algebra.Subalgebra.Basic
|
{R : Type u} →
{A : Type v} →
[inst : CommSemiring R] →
[inst_1 : Semiring A] → [inst_2 : Algebra R A] → (S : Subalgebra R A) → ↥(Subalgebra.toSubmodule S) ≃ₗ[R] ↥S
|
ENat.coe_sSup
|
Mathlib.Data.ENat.Lattice
|
∀ {s : Set ℕ}, BddAbove s → ↑(sSup s) = ⨆ a ∈ s, ↑a
|
_private.Aesop.Util.UnorderedArraySet.0.Aesop.UnorderedArraySet.mk.inj
|
Aesop.Util.UnorderedArraySet
|
∀ {α : Type u_1} {inst : BEq α} {rep rep_1 : Array α}, { rep := rep } = { rep := rep_1 } → rep = rep_1
|
StandardEtalePresentation._sizeOf_inst
|
Mathlib.RingTheory.Etale.StandardEtale
|
(R : Type u_4) →
(S : Type u_5) →
{inst : CommRing R} →
{inst_1 : CommRing S} → {inst_2 : Algebra R S} → [SizeOf R] → [SizeOf S] → SizeOf (StandardEtalePresentation R S)
|
_private.Lean.Environment.0.Lean.Visibility.private.elim
|
Lean.Environment
|
{motive : Lean.Visibility✝ → Sort u} →
(t : Lean.Visibility✝¹) → Lean.Visibility.ctorIdx✝ t = 0 → motive Lean.Visibility.private✝ → motive t
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.bv_add
|
Lean.Elab.Tactic.BVDecide.Frontend.Normalize.Simproc
|
Lean.Meta.Simp.Simproc
|
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⟩)))
|
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])
|
Int8.toInt32_neg_of_ne
|
Init.Data.SInt.Lemmas
|
∀ {x : Int8}, x ≠ -128 → (-x).toInt32 = -x.toInt32
|
_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)
|
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
|
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
|
MeasureTheory.toOuterMeasure_eq_inducedOuterMeasure
|
Mathlib.MeasureTheory.Measure.MeasureSpaceDef
|
∀ {α : Type u_1} [inst : MeasurableSpace α] {μ : MeasureTheory.Measure α},
μ.toOuterMeasure = MeasureTheory.inducedOuterMeasure (fun s x => μ s) ⋯ ⋯
|
_private.Lean.Elab.CheckTactic.0.Lean.Elab.CheckTactic.elabCheckTactic._sparseCasesOn_5
|
Lean.Elab.CheckTactic
|
{α : Type u} →
{motive : List α → Sort u_1} → (t : List α) → motive [] → (Nat.hasNotBit 1 t.ctorIdx → motive t) → motive t
|
ProofWidgets.Penrose.DiagramBuilderM.addEmbed
|
ProofWidgets.Component.PenroseDiagram
|
String → String → ProofWidgets.Html → ProofWidgets.Penrose.DiagramBuilderM Unit
|
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
|
_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)
|
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 | m] ω) ^ 2 then fun ω => (X ω - μ[X | m] ω) ^ 2
else MeasureTheory.AEStronglyMeasurable.mk ↑↑(MeasureTheory.condExpL1 hm μ fun ω => (X ω - μ[X | m] ω) ^ 2) ⋯
else 0
|
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
|
OrderDual.instLocallyFiniteOrderTop
|
Mathlib.Order.Interval.Finset.Defs
|
{α : Type u_1} → [inst : Preorder α] → [LocallyFiniteOrderBot α] → LocallyFiniteOrderTop αᵒᵈ
|
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) < ⊤
|
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.CategoryStruct.comp (CategoryTheory.CategoryStruct.comp x.as x_1.as) x_2.as) =
map (CategoryTheory.CategoryStruct.comp x.as (CategoryTheory.CategoryStruct.comp x_1.as x_2.as))
|
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
|
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
|
ENat.one_epow
|
Mathlib.Data.ENat.Pow
|
∀ {y : ℕ∞}, 1 ^ y = 1
|
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) →
f = g
|
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
|
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'
|
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)
|
instNoMinOrderElemIoc
|
Mathlib.Order.Interval.Set.Basic
|
∀ (α : Type u_1) [inst : Preorder α] [DenselyOrdered α] {x y : α}, NoMinOrder ↑(Set.Ioc x y)
|
_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
|
CommGroupWithZero.zpow._inherited_default
|
Mathlib.Algebra.GroupWithZero.Defs
|
{G₀ : Type u_2} → (G₀ → G₀ → G₀) → G₀ → (G₀ → G₀) → ℤ → G₀ → G₀
|
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)
|
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ˣ)
(b₁ b₂ : α), ↑m • (b₁ * b₂) = ↑m • b₁ * ↑m • b₂
|
Polynomial.isOpenMap_comap_C
|
Mathlib.RingTheory.Spectrum.Prime.Polynomial
|
∀ {R : Type u_1} [inst : CommRing R], IsOpenMap (PrimeSpectrum.comap Polynomial.C)
|
_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₂)
|
_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)) →
((declName : Lean.Name) →
(post : Bool) → motive (Lean.Elab.Tactic.ElabSimpArgResult.addSimproc declName post)) →
((origin : Lean.Meta.Origin) → motive (Lean.Elab.Tactic.ElabSimpArgResult.erase origin)) →
((name : Lean.Name) → motive (Lean.Elab.Tactic.ElabSimpArgResult.eraseSimproc name)) →
((simpExt? : Option Lean.Meta.SimpExtension) →
(simprocExt? : Option Lean.Meta.Simp.SimprocExtension) →
(h : (simpExt?.isSome || simprocExt?.isSome) = true) →
motive (Lean.Elab.Tactic.ElabSimpArgResult.ext simpExt? simprocExt? h)) →
(Unit → motive Lean.Elab.Tactic.ElabSimpArgResult.star) →
(Unit → motive Lean.Elab.Tactic.ElabSimpArgResult.none) → motive arg
|
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₂.R ⊕ ι)
|
ValuativeRel._aux_Mathlib_RingTheory_Valuation_ValuativeRel_Basic___unexpand_ValuativeRel_vlt_1
|
Mathlib.RingTheory.Valuation.ValuativeRel.Basic
|
Lean.PrettyPrinter.Unexpander
|
BooleanAlgebra.toHImp
|
Mathlib.Order.BooleanAlgebra.Defs
|
{α : Type u} → [self : BooleanAlgebra α] → HImp α
|
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)
|
instIsCancelVAdd
|
Mathlib.Algebra.Group.Action.Defs
|
∀ (G : Type u_9) [inst : AddCancelMonoid G], IsCancelVAdd G G
|
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
|
_private.Mathlib.Data.Multiset.ZeroCons.0.Multiset.le_singleton._simp_1_1
|
Mathlib.Data.Multiset.ZeroCons
|
∀ {α : Type u_1} (a : α), {a} = ↑[a]
|
Lean.Syntax.topDown
|
Lean.Syntax
|
Lean.Syntax → optParam Bool false → Lean.Syntax.TopDown
|
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
|
Lean.Grind.IntModule.OfNatModule.r
|
Init.Grind.Module.Envelope
|
(α : Type u) → [Lean.Grind.NatModule α] → α × α → α × α → Prop
|
SeparationQuotient.surjective_mk
|
Mathlib.Topology.Inseparable
|
∀ {X : Type u_1} [inst : TopologicalSpace X], Function.Surjective SeparationQuotient.mk
|
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
|
_private.Mathlib.Computability.PostTuringMachine.0.Turing.TM1to0.trAux.match_1.eq_1
|
Mathlib.Computability.PostTuringMachine
|
∀ {Γ : Type u_1} {Λ : Type u_2} {σ : Type u_3} (motive : Turing.TM1.Stmt Γ Λ σ → σ → Sort u_4) (d : Turing.Dir)
(q : Turing.TM1.Stmt Γ Λ σ) (v : σ)
(h_1 : (d : Turing.Dir) → (q : Turing.TM1.Stmt Γ Λ σ) → (v : σ) → motive (Turing.TM1.Stmt.move d q) v)
(h_2 : (a : Γ → σ → Γ) → (q : Turing.TM1.Stmt Γ Λ σ) → (v : σ) → motive (Turing.TM1.Stmt.write a q) v)
(h_3 : (a : Γ → σ → σ) → (q : Turing.TM1.Stmt Γ Λ σ) → (v : σ) → motive (Turing.TM1.Stmt.load a q) v)
(h_4 : (p : Γ → σ → Bool) → (q₁ q₂ : Turing.TM1.Stmt Γ Λ σ) → (v : σ) → motive (Turing.TM1.Stmt.branch p q₁ q₂) v)
(h_5 : (l : Γ → σ → Λ) → (v : σ) → motive (Turing.TM1.Stmt.goto l) v) (h_6 : (v : σ) → motive Turing.TM1.Stmt.halt v),
(match Turing.TM1.Stmt.move d q, v with
| Turing.TM1.Stmt.move d q, v => h_1 d q v
| Turing.TM1.Stmt.write a q, v => h_2 a q v
| Turing.TM1.Stmt.load a q, v => h_3 a q v
| Turing.TM1.Stmt.branch p q₁ q₂, v => h_4 p q₁ q₂ v
| Turing.TM1.Stmt.goto l, v => h_5 l v
| Turing.TM1.Stmt.halt, v => h_6 v) =
h_1 d q v
|
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 fallback = t.minKeyD fallback
|
_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)
|
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
|
LLVM.CodegenFileType.ctorIdx
|
Lean.Compiler.IR.LLVMBindings
|
LLVM.CodegenFileType → ℕ
|
HeytingAlgebra.ctorIdx
|
Mathlib.Order.Heyting.Basic
|
{α : Type u_4} → HeytingAlgebra α → ℕ
|
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
|
_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)
|
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 ⋯)
|
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₁)
|
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₂
|
Subgroup.orderIsoCon
|
Mathlib.GroupTheory.QuotientGroup.Defs
|
{G : Type u_1} → [inst : Group G] → { N // N.Normal } ≃o Con G
|
CommMonCat.forget₂CreatesLimit._proof_11
|
Mathlib.Algebra.Category.MonCat.Limits
|
∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_1, u_3} J] (F : CategoryTheory.Functor J CommMonCat)
[inst_1 : Small.{u_2, max u_2 u_3} ↑(F.comp (CategoryTheory.forget CommMonCat)).sections]
(x : CategoryTheory.Limits.Cone F),
(CategoryTheory.forget₂ CommMonCat MonCat).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
↑((F.comp (CategoryTheory.forget₂ CommMonCat MonCat)).comp (CategoryTheory.forget MonCat)).sections)
⟨fun j =>
((CategoryTheory.forget MonCat).mapCone ((CategoryTheory.forget₂ CommMonCat MonCat).mapCone x)).π.app
j v,
⋯⟩,
map_one' := ⋯, map_mul' := ⋯ } } =
(CategoryTheory.forget₂ CommMonCat MonCat).map
{
hom' :=
{
toFun := fun v =>
EquivLike.coe
(equivShrink
↑((F.comp (CategoryTheory.forget₂ CommMonCat MonCat)).comp (CategoryTheory.forget MonCat)).sections)
⟨fun j =>
((CategoryTheory.forget MonCat).mapCone ((CategoryTheory.forget₂ CommMonCat MonCat).mapCone x)).π.app
j v,
⋯⟩,
map_one' := ⋯, map_mul' := ⋯ } }
|
_private.Std.Data.DHashMap.Internal.Defs.0.Std.DHashMap.Internal.Raw₀.expand.go.induct
|
Std.Data.DHashMap.Internal.WF
|
∀ {α : Type u} {β : α → Type v} [inst : Hashable α]
(motive : ℕ → Array (Std.DHashMap.Internal.AssocList α β) → { d // 0 < d.size } → Prop),
(∀ (i : ℕ) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size })
(h : i < source.size),
have es := source[i];
have source_1 := source.set i Std.DHashMap.Internal.AssocList.nil h;
have target_1 := Std.DHashMap.Internal.AssocList.foldl (Std.DHashMap.Internal.Raw₀.reinsertAux hash) target es;
motive (i + 1) source_1 target_1 → motive i source target) →
(∀ (i : ℕ) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size }),
¬i < source.size → motive i source target) →
∀ (i : ℕ) (source : Array (Std.DHashMap.Internal.AssocList α β)) (target : { d // 0 < d.size }),
motive i source target
|
_private.Batteries.Data.RBMap.Lemmas.0.Batteries.RBNode.Ordered.memP_iff_lowerBound?.match_1_5
|
Batteries.Data.RBMap.Lemmas
|
∀ (motive : Ordering.eq = Ordering.lt → Prop) (x : Ordering.eq = Ordering.lt), motive x
|
ContinuousLinearMap.equivProdOfSurjectiveOfIsCompl.congr_simp
|
Mathlib.Analysis.Calculus.Implicit
|
∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} {G : Type u_4} [inst : NontriviallyNormedField 𝕜]
[inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F]
[inst_5 : NormedAddCommGroup G] [inst_6 : NormedSpace 𝕜 G] [inst_7 : CompleteSpace E] [inst_8 : CompleteSpace (F × G)]
(f f_1 : E →L[𝕜] F) (e_f : f = f_1) (g g_1 : E →L[𝕜] G) (e_g : g = g_1) (hf : (↑f).range = ⊤) (hg : (↑g).range = ⊤)
(hfg : IsCompl (↑f).ker (↑g).ker),
f.equivProdOfSurjectiveOfIsCompl g hf hg hfg = f_1.equivProdOfSurjectiveOfIsCompl g_1 ⋯ ⋯ ⋯
|
Std.Sat.AIG.RelabelNat.State.noConfusionType
|
Std.Sat.AIG.RelabelNat
|
Sort u →
{α : Type} →
[inst : DecidableEq α] →
[inst_1 : Hashable α] →
{decls : Array (Std.Sat.AIG.Decl α)} →
{idx : ℕ} →
Std.Sat.AIG.RelabelNat.State α decls idx →
{α' : Type} →
[inst' : DecidableEq α'] →
[inst'_1 : Hashable α'] →
{decls' : Array (Std.Sat.AIG.Decl α')} →
{idx' : ℕ} → Std.Sat.AIG.RelabelNat.State α' decls' idx' → Sort u
|
_private.Mathlib.RingTheory.OrderOfVanishing.0.Ring.ordFrac._simp_1
|
Mathlib.RingTheory.OrderOfVanishing
|
∀ {G₀ : Type u_3} [inst : GroupWithZero G₀] {a : G₀}, IsUnit a = (a ≠ 0)
|
WellFounded.Nat.fix.go.congr_simp
|
Init.WF
|
∀ {α : Sort u} {motive : α → Sort v} (h : α → ℕ)
(F F_1 : (x : α) → ((y : α) → InvImage (fun x1 x2 => x1 < x2) h y x → motive y) → motive x),
F = F_1 →
∀ (fuel fuel_1 : ℕ) (e_fuel : fuel = fuel_1) (x : α) (a : h x < fuel),
WellFounded.Nat.fix.go h F fuel x a = WellFounded.Nat.fix.go h F_1 fuel_1 x ⋯
|
hasSum_nat_jacobiTheta
|
Mathlib.NumberTheory.ModularForms.JacobiTheta.OneVariable
|
∀ {τ : ℂ}, 0 < τ.im → HasSum (fun n => Complex.exp (↑Real.pi * Complex.I * (↑n + 1) ^ 2 * τ)) ((jacobiTheta τ - 1) / 2)
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.