name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.ShortComplex.hasLeftHomology_of_epi_of_isIso_of_mono' | Mathlib.Algebra.Homology.ShortComplex.LeftHomology | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{S₁ S₂ : CategoryTheory.ShortComplex C} (φ : S₁ ⟶ S₂) [S₂.HasLeftHomology] [CategoryTheory.Epi φ.τ₁]
[CategoryTheory.IsIso φ.τ₂] [CategoryTheory.Mono φ.τ₃], S₁.HasLeftHomology |
Turing.EvalsTo.mk.inj | Mathlib.Computability.TMComputable | ∀ {σ : Type u_1} {f : σ → Option σ} {a : σ} {b : Option σ} {steps : ℕ}
{evals_in_steps : (flip bind f)^[steps] (some a) = b} {steps_1 : ℕ}
{evals_in_steps_1 : (flip bind f)^[steps_1] (some a) = b},
{ steps := steps, evals_in_steps := evals_in_steps } = { steps := steps_1, evals_in_steps := evals_in_steps_1 } →
steps = steps_1 |
CategoryTheory.Limits.BinaryBicone.ofLimitCone._proof_6 | Mathlib.CategoryTheory.Preadditive.Biproducts | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Preadditive C] {X Y : C}
{t : CategoryTheory.Limits.Cone (CategoryTheory.Limits.pair X Y)} (ht : CategoryTheory.Limits.IsLimit t),
CategoryTheory.CategoryStruct.comp
(ht.lift (CategoryTheory.Limits.BinaryFan.mk 0 (CategoryTheory.CategoryStruct.id Y)))
(t.π.app { as := CategoryTheory.Limits.WalkingPair.left }) =
0 |
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} |
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 |
AlgebraicGeometry.Etale.instFormallyUnramified | Mathlib.AlgebraicGeometry.Morphisms.Etale | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) [AlgebraicGeometry.Etale f], AlgebraicGeometry.FormallyUnramified f |
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.Defs | 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 |
List.findFinIdx?_eq_bind_find?_finIdxOf? | Init.Data.List.Find | ∀ {α : Type u_1} [inst : BEq α] [LawfulBEq α] {xs : List α} {p : α → Bool},
List.findFinIdx? p xs = (List.find? p xs).bind fun a => List.finIdxOf? a xs |
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) |
_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 α |
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₁ |
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 |
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 ⋯) |
_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) |
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 ⋯ ⋯ ⋯ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.