name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
isClosed_sUnion | Mathlib.Topology.AlexandrovDiscrete | ∀ {α : Type u_3} [inst : TopologicalSpace α] [AlexandrovDiscrete α] {S : Set (Set α)},
(∀ s ∈ S, IsClosed s) → IsClosed (⋃₀ S) |
CategoryTheory.Functor.whiskeringRight._proof_6 | Mathlib.CategoryTheory.Whiskering | ∀ (C : Type u_1) [inst : CategoryTheory.Category.{u_4, u_1} C] (D : Type u_6)
[inst_1 : CategoryTheory.Category.{u_5, u_6} D] (E : Type u_3) [inst_2 : CategoryTheory.Category.{u_2, u_3} E]
{X Y : CategoryTheory.Functor D E} (τ : X ⟶ Y) (X_1 Y_1 : CategoryTheory.Functor C D) (f : X_1 ⟶ Y_1),
CategoryTheory.CategoryStruct.comp
({ obj := fun F => F.comp X, map := fun {X_2 Y} α => CategoryTheory.Functor.whiskerRight α X, map_id := ⋯,
map_comp := ⋯ }.map
f)
{ app := fun c => τ.app (Y_1.obj c), naturality := ⋯ } =
CategoryTheory.CategoryStruct.comp { app := fun c => τ.app (X_1.obj c), naturality := ⋯ }
({ obj := fun F => F.comp Y, map := fun {X Y_2} α => CategoryTheory.Functor.whiskerRight α Y, map_id := ⋯,
map_comp := ⋯ }.map
f) |
String.Slice.Pattern.Model.Char.isLongestMatch_iff | Init.Data.String.Lemmas.Pattern.Char | ∀ {c : Char} {s : String.Slice} {pos : s.Pos},
String.Slice.Pattern.Model.IsLongestMatch c pos ↔
∃ (h : s.startPos ≠ s.endPos), pos = s.startPos.next h ∧ s.startPos.get h = c |
Std.Sat.AIG.RefVec.map.go_decl_eq._unary | Std.Sat.AIG.RefVecOperator.Map | ∀ {α : Type} [inst : Hashable α] [inst_1 : DecidableEq α] {len : ℕ}
(f : (aig : Std.Sat.AIG α) → aig.Ref → Std.Sat.AIG.Entrypoint α)
[inst_2 : Std.Sat.AIG.LawfulOperator α Std.Sat.AIG.Ref f] [inst_3 : Std.Sat.AIG.RefVec.LawfulMapOperator α f]
(_x : (aig : Std.Sat.AIG α) ×' (i : ℕ) ×' (_ : i ≤ len) ×' (_ : aig.RefVec i) ×' aig.RefVec len) (idx : ℕ)
(h1 : idx < _x.1.decls.size)
(h2 : idx < (Std.Sat.AIG.RefVec.map.go _x.1 _x.2.1 ⋯ _x.2.2.2.1 _x.2.2.2.2 f).aig.decls.size),
(Std.Sat.AIG.RefVec.map.go _x.1 _x.2.1 ⋯ _x.2.2.2.1 _x.2.2.2.2 f).aig.decls[idx] = _x.1.decls[idx] |
BooleanSubalgebra.rec | Mathlib.Order.BooleanSubalgebra | {α : Type u_2} →
[inst : BooleanAlgebra α] →
{motive : BooleanSubalgebra α → Sort u} →
((toSublattice : Sublattice α) →
(compl_mem' : ∀ {a : α}, a ∈ toSublattice.carrier → aᶜ ∈ toSublattice.carrier) →
(bot_mem' : ⊥ ∈ toSublattice.carrier) →
motive { toSublattice := toSublattice, compl_mem' := compl_mem', bot_mem' := bot_mem' }) →
(t : BooleanSubalgebra α) → motive t |
Nat.log_monotone | Mathlib.Data.Nat.Log | ∀ {b : ℕ}, Monotone (Nat.log b) |
Lean.Lsp.instFromJsonSemanticTokenModifier | Lean.Data.Lsp.LanguageFeatures | Lean.FromJson Lean.Lsp.SemanticTokenModifier |
StarMulEquiv.ext_iff | Mathlib.Algebra.Star.MonoidHom | ∀ {A : Type u_2} {B : Type u_3} [inst : Mul A] [inst_1 : Mul B] [inst_2 : Star A] [inst_3 : Star B] {f g : A ≃⋆* B},
f = g ↔ ∀ (a : A), f a = g a |
Qq.QuotedDefEq | Qq.Typ | {u : Lean.Level} → {α : Q(Sort u)} → Q(«$α») → Q(«$α») → Prop |
gc_sdiff_sup | Mathlib.Order.Heyting.Basic | ∀ {α : Type u_2} [inst : GeneralizedCoheytingAlgebra α] {a : α}, GaloisConnection (fun x => x \ a) fun x => a ⊔ x |
intervalIntegral.norm_integral_min_max | Mathlib.MeasureTheory.Integral.IntervalIntegral.Basic | ∀ {E : Type u_5} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {a b : ℝ} {μ : MeasureTheory.Measure ℝ}
(f : ℝ → E), ‖∫ (x : ℝ) in min a b..max a b, f x ∂μ‖ = ‖∫ (x : ℝ) in a..b, f x ∂μ‖ |
MvPolynomial.IsWeightedHomogeneous | Mathlib.RingTheory.MvPolynomial.WeightedHomogeneous | {R : Type u_1} →
{M : Type u_2} → [inst : CommSemiring R] → {σ : Type u_3} → [AddCommMonoid M] → (σ → M) → MvPolynomial σ R → M → Prop |
Behrend.ceil_lt_mul | Mathlib.Combinatorics.Additive.AP.Three.Behrend | ∀ {x : ℝ}, 50 / 19 ≤ x → ↑⌈x⌉₊ < 1.38 * x |
_private.Mathlib.Data.List.Defs.0.List.length_mapAccumr.match_1_1 | Mathlib.Data.List.Defs | ∀ {α : Type u_3} {β : Type u_2} {γ : Type u_1} (motive : (α → γ → γ × β) → List α → γ → Prop) (x : α → γ → γ × β)
(x_1 : List α) (x_2 : γ),
(∀ (f : α → γ → γ × β) (head : α) (x : List α) (s : γ), motive f (head :: x) s) →
(∀ (x : α → γ → γ × β) (x_3 : γ), motive x [] x_3) → motive x x_1 x_2 |
Lean.Doc.CodeBlockSuggestion.casesOn | Lean.Elab.DocString | {motive : Lean.Doc.CodeBlockSuggestion → Sort u} →
(t : Lean.Doc.CodeBlockSuggestion) →
((name : Lean.Name) →
(args moreInfo : Option String) → motive { name := name, args := args, moreInfo := moreInfo }) →
motive t |
_private.Lean.Elab.Match.0.Lean.Elab.Term.elabNoMatch.loop._sunfold | Lean.Elab.Match | Lean.Syntax → List Lean.Term → Array Lean.Syntax → Lean.Elab.TermElabM Lean.Term |
PowerSeries.hasEvalIdeal.eq_1 | Mathlib.RingTheory.PowerSeries.Evaluation | ∀ {S : Type u_2} [inst : CommRing S] [inst_1 : TopologicalSpace S] [inst_2 : IsTopologicalRing S]
[inst_3 : IsLinearTopology S S],
PowerSeries.hasEvalIdeal = { carrier := {a | PowerSeries.HasEval a}, add_mem' := ⋯, zero_mem' := ⋯, smul_mem' := ⋯ } |
Mathlib.Tactic.Order.ToInt.toInt_nlt_toInt | Mathlib.Tactic.Order.ToInt | ∀ {α : Type u_1} [inst : LinearOrder α] {n : ℕ} (val : Fin n → α) (i j : Fin n),
¬Mathlib.Tactic.Order.ToInt.toInt val i < Mathlib.Tactic.Order.ToInt.toInt val j ↔ ¬val i < val j |
Rep.quotientToInvariantsFunctor._proof_4 | Mathlib.RepresentationTheory.Invariants | ∀ (k : Type u_1) {G : Type u_1} [inst : CommRing k] [inst_1 : Group G] (S : Subgroup G) [inst_2 : S.Normal]
{X Y : Rep k G} (f : X ⟶ Y) (g : G),
CategoryTheory.CategoryStruct.comp ((X.quotientToInvariants S).ρ ↑g)
((Rep.invariantsFunctor k ↥S).map ((Action.res (ModuleCat k) S.subtype).map f)) =
CategoryTheory.CategoryStruct.comp ((Rep.invariantsFunctor k ↥S).map ((Action.res (ModuleCat k) S.subtype).map f))
((Y.quotientToInvariants S).ρ ↑g) |
BitVec.getLsbD_reverse | Init.Data.BitVec.Lemmas | ∀ {w i : ℕ} {x : BitVec w}, x.reverse.getLsbD i = x.getMsbD i |
IsSymmetricAlgebra.lift_eq | Mathlib.LinearAlgebra.SymmetricAlgebra.Basic | ∀ {R : Type u_1} {M : Type u_2} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {A : Type u_3}
[inst_3 : CommSemiring A] [inst_4 : Algebra R A] {f : M →ₗ[R] A} (h : IsSymmetricAlgebra f) {A' : Type u_4}
[inst_5 : CommSemiring A'] [inst_6 : Algebra R A'] (g : M →ₗ[R] A') (a : M), (h.lift g) (f a) = g a |
HahnSeries.instLinearOrderLex | Mathlib.RingTheory.HahnSeries.Lex | {Γ : Type u_1} →
{R : Type u_2} → [inst : LinearOrder Γ] → [inst_1 : Zero R] → [LinearOrder R] → LinearOrder (Lex (HahnSeries Γ R)) |
LinearIsometryEquiv._sizeOf_inst | Mathlib.Analysis.Normed.Operator.LinearIsometry | {R : Type u_1} →
{R₂ : Type u_2} →
{inst : Semiring R} →
{inst_1 : Semiring R₂} →
(σ₁₂ : R →+* R₂) →
{σ₂₁ : R₂ →+* R} →
{inst_2 : RingHomInvPair σ₁₂ σ₂₁} →
{inst_3 : RingHomInvPair σ₂₁ σ₁₂} →
(E : Type u_11) →
(E₂ : Type u_12) →
{inst_4 : SeminormedAddCommGroup E} →
{inst_5 : SeminormedAddCommGroup E₂} →
{inst_6 : Module R E} →
{inst_7 : Module R₂ E₂} →
[SizeOf R] → [SizeOf R₂] → [SizeOf E] → [SizeOf E₂] → SizeOf (E ≃ₛₗᵢ[σ₁₂] E₂) |
MulOpposite.op_le_op._simp_2 | Mathlib.Algebra.Order.Group.Opposite | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, (MulOpposite.op a ≤ MulOpposite.op b) = (a ≤ b) |
Lean.Parser.Term.showTermElabImpl._regBuiltin.Lean.Parser.Term.showTermElabImpl.formatter_9 | Lean.Parser.Term | IO Unit |
Std.TreeSet._sizeOf_inst | Std.Data.TreeSet.Basic | (α : Type u) → (cmp : autoParam (α → α → Ordering) Std.TreeSet._auto_1) → [SizeOf α] → SizeOf (Std.TreeSet α cmp) |
ContinuousMap.instNorm | Mathlib.Topology.ContinuousMap.Compact | {α : Type u_1} →
{E : Type u_3} → [inst : TopologicalSpace α] → [CompactSpace α] → [inst_2 : SeminormedAddCommGroup E] → Norm C(α, E) |
neg_sub_neg | Mathlib.Algebra.Group.Basic | ∀ {α : Type u_1} [inst : SubtractionCommMonoid α] (a b : α), -a - -b = b - a |
LineDeriv.iteratedLineDerivOp_fin_zero | Mathlib.Analysis.Distribution.DerivNotation | ∀ {V : Type u_11} {E : Type u_12} [inst : LineDeriv V E E] (m : Fin 0 → V) (f : E),
LineDeriv.iteratedLineDerivOp m f = f |
_private.Mathlib.LinearAlgebra.Span.Defs.0.Submodule.mem_sSup_of_directed._simp_1_1 | Mathlib.LinearAlgebra.Span.Defs | ∀ {α : Type u} {s : Set α} {p : ↑s → Prop}, (∃ x, p x) = ∃ x, ∃ (h : x ∈ s), p ⟨x, h⟩ |
MeasureTheory.«_aux_Mathlib_MeasureTheory_Integral_Bochner_Basic___macroRules_MeasureTheory_term∫_,_∂__1» | Mathlib.MeasureTheory.Integral.Bochner.Basic | Lean.Macro |
Std.DTreeMap.get?_inter_of_not_mem_left | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t₁ t₂ : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Std.LawfulEqCmp cmp] {k : α}, k ∉ t₁ → (t₁ ∩ t₂).get? k = none |
MeasureTheory.Integrable.comp_snd_iff | Mathlib.MeasureTheory.Integral.Prod | ∀ {α : Type u_1} {β : Type u_2} {E : Type u_3} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β]
{μ : MeasureTheory.Measure α} {ν : MeasureTheory.Measure β} [inst_2 : NormedAddCommGroup E] [MeasureTheory.SFinite ν]
[MeasureTheory.IsFiniteMeasure μ] {f : β → E},
μ ≠ 0 → (MeasureTheory.Integrable (fun x => f x.2) (μ.prod ν) ↔ MeasureTheory.Integrable f ν) |
Multiset.chooseX | Mathlib.Data.Multiset.Basic | {α : Type u_1} → (p : α → Prop) → [DecidablePred p] → (l : Multiset α) → (∃! a, a ∈ l ∧ p a) → { a // a ∈ l ∧ p a } |
ExtremallyDisconnected.open_closure | Mathlib.Topology.ExtremallyDisconnected | ∀ {X : Type u} {inst : TopologicalSpace X} [self : ExtremallyDisconnected X] (U : Set X), IsOpen U → IsOpen (closure U) |
_private.Mathlib.Tactic.Linter.EmptyLine.0.Mathlib.Linter.EmptyLine.emptyLineLinter.match_1 | Mathlib.Tactic.Linter.EmptyLine | (motive : Lean.MessageSeverity → Sort u_1) →
(x : Lean.MessageSeverity) →
(Unit → motive Lean.MessageSeverity.information) → ((x : Lean.MessageSeverity) → motive x) → motive x |
Lean.Lsp.FileEvent | Lean.Data.Lsp.Workspace | Type |
CategoryTheory.Limits.isoBiprodZero_inv | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{X Y : C} [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct X Y] (hY : CategoryTheory.Limits.IsZero Y),
(CategoryTheory.Limits.isoBiprodZero hY).inv = CategoryTheory.Limits.biprod.fst |
IsometryEquiv.divRight_toEquiv | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type v} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [inst_2 : IsIsometricSMul Gᵐᵒᵖ G] (c : G),
(IsometryEquiv.divRight c).toEquiv = Equiv.divRight c |
Matroid.isRkFinite_iff_exists_isBasis' | Mathlib.Combinatorics.Matroid.Rank.Finite | ∀ {α : Type u_1} {M : Matroid α} {X : Set α}, M.IsRkFinite X ↔ ∃ I, M.IsBasis' I X ∧ I.Finite |
Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput.casesOn | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Carry | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{motive : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig → Sort u} →
(t : Std.Tactic.BVDecide.BVExpr.bitblast.OverflowInput aig) →
((w : ℕ) → (vec : aig.BinaryRefVec w) → (cin : aig.Ref) → motive { w := w, vec := vec, cin := cin }) →
motive t |
Std.DHashMap.Internal.Raw₀.wfImp_insertMany | Std.Data.DHashMap.Internal.WF | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α] [LawfulHashable α] {ρ : Type w}
[inst_4 : ForIn Id ρ ((a : α) × β a)] {m : Std.DHashMap.Internal.Raw₀ α β} {l : ρ},
Std.DHashMap.Internal.Raw.WFImp ↑m → Std.DHashMap.Internal.Raw.WFImp ↑↑(m.insertMany l) |
Field.Emb.Cardinal.succEquiv._proof_7 | Mathlib.FieldTheory.CardinalEmb | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E]
[rank_inf : Fact (Cardinal.aleph0 ≤ Module.rank F E)] [inst_3 : Algebra.IsAlgebraic F E]
(i : (Module.rank F E).ord.ToType),
IsScalarTower F
(↥(IntermediateField.adjoin F
(⇑(Field.Emb.Cardinal.wellOrderedBasis F E) ∘ Field.Emb.Cardinal.leastExt F E '' Set.Iio i)))
E |
RelHom.id_apply | Mathlib.Order.RelIso.Basic | ∀ {α : Type u_1} (r : α → α → Prop) (x : α), (RelHom.id r) x = x |
Cardinal.nat_le_lift_iff._simp_1 | Mathlib.SetTheory.Cardinal.Order | ∀ {n : ℕ} {a : Cardinal.{u}}, (↑n ≤ Cardinal.lift.{v, u} a) = (↑n ≤ a) |
MvPFunctor.WPath._sizeOf_inst | Mathlib.Data.PFunctor.Multivariate.W | {n : ℕ} → (P : MvPFunctor.{u} (n + 1)) → (a : P.last.W) → (a_1 : Fin2 n) → SizeOf (P.WPath a a_1) |
CategoryTheory.Pi.laxMonoidalPi._proof_10 | Mathlib.CategoryTheory.Pi.Monoidal | ∀ {I : Type u_2} {C : I → Type u_3} [inst : (i : I) → CategoryTheory.Category.{u_1, u_3} (C i)]
[inst_1 : (i : I) → CategoryTheory.MonoidalCategory (C i)] {D : I → Type u_5}
[inst_2 : (i : I) → CategoryTheory.Category.{u_4, u_5} (D i)]
[inst_3 : (i : I) → CategoryTheory.MonoidalCategory (D i)] (F : (i : I) → CategoryTheory.Functor (D i) (C i))
[inst_4 : (i : I) → (F i).LaxMonoidal] (X : (i : I) → D i),
(CategoryTheory.MonoidalCategoryStruct.rightUnitor ((CategoryTheory.Functor.pi F).obj X)).hom =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft ((CategoryTheory.Functor.pi F).obj X) fun i =>
CategoryTheory.Functor.LaxMonoidal.ε (F i))
(CategoryTheory.CategoryStruct.comp
(fun i =>
CategoryTheory.Functor.LaxMonoidal.μ (F i) (X i)
(CategoryTheory.MonoidalCategoryStruct.tensorUnit ((i : I) → D i) i))
((CategoryTheory.Functor.pi F).map (CategoryTheory.MonoidalCategoryStruct.rightUnitor X).hom)) |
EuclideanGeometry.Sphere.IsDiameter.midpoint_eq_center | Mathlib.Geometry.Euclidean.Sphere.Basic | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : NormedSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {s : EuclideanGeometry.Sphere P} {p₁ p₂ : P},
s.IsDiameter p₁ p₂ → midpoint ℝ p₁ p₂ = s.center |
Dilation.ratio_comp' | Mathlib.Topology.MetricSpace.Dilation | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {g : β →ᵈ γ} {f : α →ᵈ β},
(∃ x y, edist x y ≠ 0 ∧ edist x y ≠ ⊤) → Dilation.ratio (g.comp f) = Dilation.ratio g * Dilation.ratio f |
Nat.count_le_cardinal | Mathlib.SetTheory.Cardinal.NatCount | ∀ {p : ℕ → Prop} [inst : DecidablePred p] (n : ℕ), ↑(Nat.count p n) ≤ Cardinal.mk ↑{k | p k} |
Aesop.GoalUnsafe.noConfusion | Aesop.Tree.Data | {P : Sort u} → {t t' : Aesop.GoalUnsafe} → t = t' → Aesop.GoalUnsafe.noConfusionType P t t' |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.initFn.match_1._@.Mathlib.Tactic.CategoryTheory.Elementwise.3754623819._hygCtx._hyg.2 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Option (Lean.Level × Lean.Level) → Sort u_1) →
(level? : Option (Lean.Level × Lean.Level)) →
((levelW levelUF : Lean.Level) → motive (some (levelW, levelUF))) →
((x : Option (Lean.Level × Lean.Level)) → motive x) → motive level? |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.DefEqM.Context._sizeOf_1 | Lean.Meta.Sym.Pattern | Lean.Meta.Sym.DefEqM.Context✝ → ℕ |
_private.Mathlib.AlgebraicGeometry.Cover.Open.0.AlgebraicGeometry.Scheme.OpenCover.ext_elem._simp_1_2 | Mathlib.AlgebraicGeometry.Cover.Open | ∀ {α : Type u} {ι : Sort v} {x : α} {s : ι → Set α}, (x ∈ ⋃ i, s i) = ∃ i, x ∈ s i |
Std.DHashMap.Internal.Raw₀.contains_diff_eq_false_of_contains_eq_false_left | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} [inst : BEq α] [inst_1 : Hashable α] {m₁ m₂ : Std.DHashMap.Internal.Raw₀ α β}
[EquivBEq α] [LawfulHashable α],
(↑m₁).WF → (↑m₂).WF → ∀ {k : α}, m₁.contains k = false → (m₁.diff m₂).contains k = false |
SpecialLinearGroup.instGroup._proof_10 | Mathlib.LinearAlgebra.SpecialLinearGroup | ∀ {R : Type u_1} {V : Type u_2} [inst : CommRing R] [inst_1 : AddCommGroup V] [inst_2 : Module R V] (n : ℕ)
(x : SpecialLinearGroup R V), x ^ Int.negSucc n = (x ^ ↑n.succ)⁻¹ |
CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.rightHomologyData._proof_7 | Mathlib.Algebra.Homology.ShortComplex.Abelian | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Abelian C]
(S : CategoryTheory.ShortComplex C) {kf : CategoryTheory.Limits.KernelFork S.g}
{cc : CategoryTheory.Limits.CokernelCofork S.f} (hkf : CategoryTheory.Limits.IsLimit kf)
(hcc : CategoryTheory.Limits.IsColimit cc) {H : C} {π : kf.pt ⟶ H} {ι : H ⟶ cc.pt}
(fac :
CategoryTheory.CategoryStruct.comp (CategoryTheory.Limits.Fork.ι kf) (CategoryTheory.Limits.Cofork.π cc) =
CategoryTheory.CategoryStruct.comp π ι)
[inst_2 : CategoryTheory.Epi π] [inst_3 : CategoryTheory.Mono ι],
CategoryTheory.CategoryStruct.comp
(CategoryTheory.ShortComplex.HomologyData.ofEpiMonoFactorisation.isoHomology S hkf hcc fac).hom
(CategoryTheory.Limits.Fork.ι (CategoryTheory.Limits.KernelFork.ofι S.homologyι ⋯)) =
CategoryTheory.Limits.Fork.ι
((CategoryTheory.Limits.Cones.postcompose
(CategoryTheory.Limits.parallelPair.ext (S.isoOpcyclesOfIsColimit hcc)
(CategoryTheory.Iso.refl
((CategoryTheory.Limits.parallelPair
((hcc.ofIsoColimit (CategoryTheory.Limits.Cofork.ext (CategoryTheory.Iso.refl cc.pt) ⋯)).desc
(CategoryTheory.Limits.CokernelCofork.ofπ S.g ⋯))
0).obj
CategoryTheory.Limits.WalkingParallelPair.one))
⋯ ⋯).hom).obj
(CategoryTheory.Limits.KernelFork.ofι ι ⋯)) |
Std.Do.PostShape.pure.sizeOf_spec | Std.Do.PostCond | sizeOf Std.Do.PostShape.pure = 1 |
_private.Mathlib.Algebra.Order.Group.Pointwise.Interval.0.Set.preimage_mul_const_Icc_of_neg._simp_1_1 | Mathlib.Algebra.Order.Group.Pointwise.Interval | ∀ {α : Type u_1} [inst : Preorder α] {a b : α}, Set.Icc a b = Set.Ici a ∩ Set.Iic b |
_private.Mathlib.Analysis.InnerProductSpace.Semisimple.0.LinearMap.IsSymmetric.isFinitelySemisimple._simp_1_1 | Mathlib.Analysis.InnerProductSpace.Semisimple | ∀ {α : Type u_1} [inst : SemilatticeInf α] [inst_1 : OrderBot α] {a b : α}, Disjoint a b = (a ⊓ b = ⊥) |
_private.Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree.0.WeierstrassCurve.natDegree_preΨ'_pos._simp_1_1 | Mathlib.AlgebraicGeometry.EllipticCurve.DivisionPolynomial.Degree | ∀ {a b : ℕ}, (0 < a / b) = (0 < b ∧ b ≤ a) |
_private.Lean.Meta.AppBuilder.0.Lean.Meta.mkEqTrans?.match_1 | Lean.Meta.AppBuilder | (motive : Option Lean.Expr → Option Lean.Expr → Sort u_1) →
(h₁? h₂? : Option Lean.Expr) →
(Unit → motive none none) →
((h : Lean.Expr) → motive none (some h)) →
((h : Lean.Expr) → motive (some h) none) → ((h₁ h₂ : Lean.Expr) → motive (some h₁) (some h₂)) → motive h₁? h₂? |
Std.ExtTreeMap.getD_ofList_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {β : Type v} {cmp : α → α → Ordering} [inst : Std.TransCmp cmp] {l : List (α × β)} {k k' : α},
cmp k k' = Ordering.eq →
∀ {v fallback : β},
List.Pairwise (fun a b => ¬cmp a.1 b.1 = Ordering.eq) l →
(k, v) ∈ l → (Std.ExtTreeMap.ofList l cmp).getD k' fallback = v |
_private.Mathlib.Dynamics.OmegaLimit.0.mem_omegaLimit_iff_frequently₂._simp_1_2 | Mathlib.Dynamics.OmegaLimit | ∀ {α : Type u_1} {β : Type u_2} {f : α → β} {s : Set α} {t : Set β}, (f '' s ∩ t).Nonempty = (s ∩ f ⁻¹' t).Nonempty |
ENat.toENNReal_ne_top._simp_1 | Mathlib.Data.Real.ENatENNReal | ∀ {n : ℕ∞}, (↑n ≠ ⊤) = (n ≠ ⊤) |
Matroid.loopless_iff | Mathlib.Combinatorics.Matroid.Loop | ∀ {α : Type u_1} (M : Matroid α), M.Loopless ↔ M.loops = ∅ |
FirstOrder.Language.BoundedFormula.sumElim_comp_relabelAux | Mathlib.ModelTheory.Syntax | ∀ {M : Type w} {α : Type u'} {β : Type v'} {n m : ℕ} {g : α → β ⊕ Fin n} {v : β → M} {xs : Fin (n + m) → M},
Sum.elim v xs ∘ FirstOrder.Language.BoundedFormula.relabelAux g m =
Sum.elim (Sum.elim v (xs ∘ Fin.castAdd m) ∘ g) (xs ∘ Fin.natAdd n) |
_private.Init.System.FilePath.0.System.instHashableFilePath.hash.match_1 | Init.System.FilePath | (motive : System.FilePath → Sort u_1) → (x : System.FilePath) → ((a : String) → motive { toString := a }) → motive x |
Finset.inf'._proof_1 | Mathlib.Data.Finset.Lattice.Fold | ∀ {α : Type u_1} {β : Type u_2} [inst : SemilatticeInf α] (s : Finset β),
s.Nonempty → ∀ (f : β → α), s.inf (WithTop.some ∘ f) ≠ ⊤ |
Filter.div_mem_div | Mathlib.Order.Filter.Pointwise | ∀ {α : Type u_2} [inst : Div α] {f g : Filter α} {s t : Set α}, s ∈ f → t ∈ g → s / t ∈ f / g |
Lean.FuzzyMatching.CharType.separator.elim | Lean.Data.FuzzyMatching | {motive : Lean.FuzzyMatching.CharType → Sort u} →
(t : Lean.FuzzyMatching.CharType) → t.ctorIdx = 2 → motive Lean.FuzzyMatching.CharType.separator → motive t |
MeasureTheory.pdf.eq_of_map_eq_withDensity' | Mathlib.Probability.Density | ∀ {Ω : Type u_1} {E : Type u_2} [inst : MeasurableSpace E] {m : MeasurableSpace Ω} {ℙ : MeasureTheory.Measure Ω}
{μ : MeasureTheory.Measure E} [MeasureTheory.SigmaFinite μ] {X : Ω → E} [MeasureTheory.HasPDF X ℙ μ]
(f : E → ENNReal),
AEMeasurable f μ → (MeasureTheory.Measure.map X ℙ = μ.withDensity f ↔ MeasureTheory.pdf X ℙ μ =ᵐ[μ] f) |
mabs_div_lt_of_one_le_of_lt | Mathlib.Algebra.Order.Group.Abs | ∀ {G : Type u_1} [inst : CommGroup G] [inst_1 : LinearOrder G] [IsOrderedMonoid G] {a b n : G},
1 ≤ a → a < n → 1 ≤ b → b < n → |a / b|ₘ < n |
lebesgue_number_of_compact_open | Mathlib.Topology.UniformSpace.Compact | ∀ {α : Type ua} [inst : UniformSpace α] {K U : Set α},
IsCompact K → IsOpen U → K ⊆ U → ∃ V ∈ uniformity α, IsOpen V ∧ ∀ x ∈ K, UniformSpace.ball x V ⊆ U |
Array.mergeDedupWith.go._unary._proof_2 | Batteries.Data.Array.Merge | ∀ {α : Type u_1} (xs ys acc : Array α) (i j : ℕ),
¬i ≥ xs.size →
∀ (hj : ¬j ≥ ys.size),
InvImage (fun x1 x2 => x1 < x2)
(fun x => PSigma.casesOn x fun acc i => PSigma.casesOn i fun i j => xs.size + ys.size - (i + j))
⟨acc.push ys[j], ⟨i, j + 1⟩⟩ ⟨acc, ⟨i, j⟩⟩ |
Submodule.smul_le_smul | Mathlib.Algebra.Algebra.Operations | ∀ {R : Type u} [inst : CommSemiring R] {A : Type v} [inst_1 : CommSemiring A] [inst_2 : Algebra R A]
{s t : SetSemiring A} {M N : Submodule R A}, SetSemiring.down s ⊆ SetSemiring.down t → M ≤ N → s • M ≤ t • N |
MeasureTheory.measureReal_abs_dual_gt_le_integral_charFunDual | Mathlib.MeasureTheory.Measure.IntegralCharFun | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] {mE : MeasurableSpace E}
[OpensMeasurableSpace E] {μ : MeasureTheory.Measure E} [MeasureTheory.IsProbabilityMeasure μ] (L : StrongDual ℝ E)
{r : ℝ},
0 < r → μ.real {x | r < |L x|} ≤ 2⁻¹ * r * ‖∫ (t : ℝ) in -2 * r⁻¹..2 * r⁻¹, 1 - MeasureTheory.charFunDual μ (t • L)‖ |
finRotate_last | Mathlib.Logic.Equiv.Fin.Rotate | ∀ {n : ℕ}, (finRotate (n + 1)) (Fin.last n) = 0 |
Finset.instAddTorsorForall | Mathlib.LinearAlgebra.AffineSpace.Combination | {k : Type u_1} → [inst : Ring k] → {ι : Type u_4} → AddTorsor (ι → k) (ι → k) |
Std.Sat.AIG.RefVec.IfInput.rec | Std.Sat.AIG.If | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{aig : Std.Sat.AIG α} →
{w : ℕ} →
{motive : Std.Sat.AIG.RefVec.IfInput aig w → Sort u} →
((discr : aig.Ref) → (lhs rhs : aig.RefVec w) → motive { discr := discr, lhs := lhs, rhs := rhs }) →
(t : Std.Sat.AIG.RefVec.IfInput aig w) → motive t |
InnerProductSpace.canonicalCovariantTensor.congr_simp | Mathlib.Analysis.Distribution.DerivNotation | ∀ (E : Type u_1) [inst : NormedAddCommGroup E] [inst_1 : InnerProductSpace ℝ E] [inst_2 : FiniteDimensional ℝ E],
InnerProductSpace.canonicalCovariantTensor E = InnerProductSpace.canonicalCovariantTensor E |
BitVec.not_lt_zero._simp_1 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w}, (x < 0#w) = False |
imp_false | Init.Core | ∀ {a : Prop}, a → False ↔ ¬a |
CategoryTheory.categoryFree._proof_5 | Mathlib.Algebra.Category.ModuleCat.Adjunctions | ∀ (R : Type u_1) [inst : CommRing R] (C : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} C]
{W X Y Z : CategoryTheory.Free R C} (f : (W ⟶ X) →₀ R) (g : (X ⟶ Y) →₀ R) (h : (Y ⟶ Z) →₀ R),
((f.sum fun f' s => g.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t).sum fun f' s =>
h.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t) =
f.sum fun f' s =>
(g.sum fun f' s => h.sum fun g' t => fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t).sum fun g' t =>
fun₀ | CategoryTheory.CategoryStruct.comp f' g' => s * t |
_private.Mathlib.Data.Set.Prod.0.Set.compl_prod_eq_union._proof_1_1 | Mathlib.Data.Set.Prod | ∀ {α : Type u_1} {β : Type u_2} (s : Set α) (t : Set β), (s ×ˢ t)ᶜ = sᶜ ×ˢ Set.univ ∪ Set.univ ×ˢ tᶜ |
upperPolar_empty | Mathlib.Order.Concept | ∀ {α : Type u_2} {β : Type u_3} (r : α → β → Prop), upperPolar r ∅ = Set.univ |
AlgebraicGeometry.Scheme.Modules.conjugateEquiv_pullbackId_hom | Mathlib.AlgebraicGeometry.Modules.Sheaf | ∀ (X : AlgebraicGeometry.Scheme),
(CategoryTheory.conjugateEquiv CategoryTheory.Adjunction.id
(AlgebraicGeometry.Scheme.Modules.pullbackPushforwardAdjunction (CategoryTheory.CategoryStruct.id X)))
(AlgebraicGeometry.Scheme.Modules.pullbackId X).hom =
(AlgebraicGeometry.Scheme.Modules.pushforwardId X).inv |
HomologicalComplex₂.toGradedObjectMap | Mathlib.Algebra.Homology.HomologicalBicomplex | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
[inst_1 : CategoryTheory.Limits.HasZeroMorphisms C] →
{I₁ : Type u_2} →
{I₂ : Type u_3} →
{c₁ : ComplexShape I₁} →
{c₂ : ComplexShape I₂} →
{K L : HomologicalComplex₂ C c₁ c₂} → (K ⟶ L) → (K.toGradedObject ⟶ L.toGradedObject) |
Lean.Meta.useEtaStruct | Lean.Meta.Basic | Lean.Name → Lean.MetaM Bool |
CategoryTheory.Endofunctor.Algebra.functorOfNatTransId_inv_app_f | Mathlib.CategoryTheory.Endofunctor.Algebra | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {F : CategoryTheory.Functor C C}
(X : CategoryTheory.Endofunctor.Algebra F),
(CategoryTheory.Endofunctor.Algebra.functorOfNatTransId.inv.app X).f = CategoryTheory.CategoryStruct.id X.a |
SkewMonoidAlgebra.coeff_single | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : AddMonoid k] (a : G) (b : k) [inst_1 : DecidableEq G],
(SkewMonoidAlgebra.single a b).coeff = Pi.single a b |
Filter.Germ.total | Mathlib.Order.Filter.FilterProduct | ∀ {α : Type u} {β : Type v} {φ : Ultrafilter α} [inst : LE β] [Std.Total fun x1 x2 => x1 ≤ x2],
Std.Total fun x1 x2 => x1 ≤ x2 |
_private.Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect.0.Lean.Elab.Tactic.BVDecide.Frontend.LemmaM.run.match_1 | Lean.Elab.Tactic.BVDecide.Frontend.BVDecide.Reflect | {α : Type} →
(motive : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState → Sort u_1) →
(__discr : α × Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) →
((res : α) → (state : Lean.Elab.Tactic.BVDecide.Frontend.LemmaState) → motive (res, state)) → motive __discr |
instEstimatorNatHAddThunkProd | Mathlib.Deprecated.Estimator | (a b : Thunk ℕ) → {εa : Type u_3} → {εb : Type u_4} → [Estimator a εa] → [Estimator b εb] → Estimator (a + b) (εa × εb) |
EReal.sub_add_cancel_right | Mathlib.Data.EReal.Operations | ∀ {a : EReal} {b : ℝ}, ↑b - (a + ↑b) = -a |
_private.Std.Data.DTreeMap.Internal.Lemmas.0.Std.DTreeMap.Internal.Impl.contains_union._simp_1_2 | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {instOrd : Ord α} {a b : α}, (compare a b ≠ Ordering.eq) = ((a == b) = false) |
_private.Mathlib.Topology.Sets.VietorisTopology.0.TopologicalSpace.vietoris.isCompact_aux._proof_1_7 | Mathlib.Topology.Sets.VietorisTopology | ∀ {α : Type u_1} [inst : TopologicalSpace α] {K : Set α} {s : Set (Set α)},
s ⊆ 𝒫 K →
∀ (S : Set (Set (Set α))),
∀ L ∈ s,
L \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ⊆ K \ ⋃₀ {U | IsOpen U ∧ {s | (s ∩ U).Nonempty} ∈ S} ∩ L |
Alexandrov.principals | Mathlib.Topology.Sheaves.Alexandrov | (X : Type v) →
[inst : TopologicalSpace X] →
[inst_1 : Preorder X] → [Topology.IsUpperSet X] → CategoryTheory.Functor X (TopologicalSpace.Opens X)ᵒᵖ |
ComplexShape.σ_symm | Mathlib.Algebra.Homology.ComplexShapeSigns | ∀ {I₁ : Type u_1} {I₂ : Type u_2} {I₁₂ : Type u_4} (c₁ : ComplexShape I₁) (c₂ : ComplexShape I₂)
(c₁₂ : ComplexShape I₁₂) [inst : TotalComplexShape c₁ c₂ c₁₂] [inst_1 : TotalComplexShape c₂ c₁ c₁₂]
[inst_2 : TotalComplexShapeSymmetry c₁ c₂ c₁₂] [inst_3 : TotalComplexShapeSymmetry c₂ c₁ c₁₂]
[TotalComplexShapeSymmetrySymmetry c₁ c₂ c₁₂] (i₁ : I₁) (i₂ : I₂), c₂.σ c₁ c₁₂ i₂ i₁ = c₁.σ c₂ c₁₂ i₁ i₂ |
_private.Mathlib.Tactic.NormNum.Ineq.0.Mathlib.Meta.NormNum.evalLE.core.match_3 | Mathlib.Tactic.NormNum.Ineq | {u : Lean.Level} →
{α : Q(Type u)} →
{a b : Q(«$α»)} →
(motive : Mathlib.Meta.NormNum.Result a → Mathlib.Meta.NormNum.Result b → Sort u_1) →
(ra : Mathlib.Meta.NormNum.Result a) →
(rb : Mathlib.Meta.NormNum.Result b) →
((val : Bool) →
(proof : Lean.Expr) →
(x : Mathlib.Meta.NormNum.Result b) → motive (Mathlib.Meta.NormNum.Result'.isBool val proof) x) →
((x : Mathlib.Meta.NormNum.Result a) →
(val : Bool) → (proof : Lean.Expr) → motive x (Mathlib.Meta.NormNum.Result'.isBool val proof)) →
((inst : Q(DivisionSemiring «$α»)) →
(q : ℚ) →
(n d : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsNNRat «$a» «$n» «$d»)) →
(x : Mathlib.Meta.NormNum.Result b) →
motive (Mathlib.Meta.NormNum.Result'.isNNRat inst q n d proof) x) →
((x : Mathlib.Meta.NormNum.Result a) →
(inst : Q(DivisionSemiring «$α»)) →
(q : ℚ) →
(n d : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsNNRat «$b» «$n» «$d»)) →
motive x (Mathlib.Meta.NormNum.Result'.isNNRat inst q n d proof)) →
((inst : Q(DivisionRing «$α»)) →
(q : ℚ) →
(n d : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsRat «$a» (Int.negOfNat «$n») «$d»)) →
(x : Mathlib.Meta.NormNum.Result b) →
motive (Mathlib.Meta.NormNum.Result'.isNegNNRat inst q n d proof) x) →
((x : Mathlib.Meta.NormNum.Result a) →
(inst : Q(DivisionRing «$α»)) →
(q : ℚ) →
(n d : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsRat «$b» (Int.negOfNat «$n») «$d»)) →
motive x (Mathlib.Meta.NormNum.Result'.isNegNNRat inst q n d proof)) →
((inst : Q(Ring «$α»)) →
(lit : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsInt «$a» (Int.negOfNat «$lit»))) →
(x : Mathlib.Meta.NormNum.Result b) →
motive (Mathlib.Meta.NormNum.Result'.isNegNat inst lit proof) x) →
((x : Mathlib.Meta.NormNum.Result a) →
(inst : Q(Ring «$α»)) →
(lit : Q(ℕ)) →
(proof : Q(Mathlib.Meta.NormNum.IsInt «$b» (Int.negOfNat «$lit»))) →
motive x (Mathlib.Meta.NormNum.Result'.isNegNat inst lit proof)) →
((ra : Q(AddMonoidWithOne «$α»)) →
(na : Q(ℕ)) →
(pa : Q(Mathlib.Meta.NormNum.IsNat «$a» «$na»)) →
(rb : Q(AddMonoidWithOne «$α»)) →
(nb : Q(ℕ)) →
(pb : Q(Mathlib.Meta.NormNum.IsNat «$b» «$nb»)) →
motive (Mathlib.Meta.NormNum.Result'.isNat ra na pa)
(Mathlib.Meta.NormNum.Result'.isNat rb nb pb)) →
motive ra rb |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.