name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
_private.Mathlib.Data.PFun.0.PFun.mem_prodLift._simp_1_6 | Mathlib.Data.PFun | ∀ {α : Sort u_1} {p : α → Prop} {b : Prop}, (∃ x, p x ∧ b) = ((∃ x, p x) ∧ b) |
AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeftIsLimit | Mathlib.Geometry.RingedSpace.OpenImmersion | {X Y Z : AlgebraicGeometry.LocallyRingedSpace} →
(f : X ⟶ Z) →
(g : Y ⟶ Z) →
[H : AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion f] →
CategoryTheory.Limits.IsLimit (AlgebraicGeometry.LocallyRingedSpace.IsOpenImmersion.pullbackConeOfLeft f g) |
List.dropWhile.eq_def | Init.Data.List.TakeDrop | ∀ {α : Type u} (p : α → Bool) (x : List α),
List.dropWhile p x =
match x with
| [] => []
| a :: l =>
match p a with
| true => List.dropWhile p l
| false => a :: l |
Finsupp.mem_submodule_iff | Mathlib.LinearAlgebra.Finsupp.Pi | ∀ {R : Type u_1} {M : Type u_2} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M] {α : Type u_5}
(S : α → Submodule R M) (x : α →₀ M), x ∈ Finsupp.submodule S ↔ ∀ (i : α), x i ∈ S i |
Submonoid.val_mem_of_mem_units | Mathlib.Algebra.Group.Submonoid.Units | ∀ {M : Type u_1} [inst : Monoid M] (S : Submonoid M) {x : Mˣ}, x ∈ S.units → ↑x ∈ S |
Finsupp.mem_neLocus | Mathlib.Data.Finsupp.NeLocus | ∀ {α : Type u_1} {N : Type u_3} [inst : DecidableEq α] [inst_1 : DecidableEq N] [inst_2 : Zero N] {f g : α →₀ N}
{a : α}, a ∈ f.neLocus g ↔ f a ≠ g a |
Std.DTreeMap.isSome_minKey?_of_mem | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp] {k : α},
k ∈ t → t.minKey?.isSome = true |
CategoryTheory.Functor.mapTriangleCommShiftIso_inv_app_hom₁ | Mathlib.CategoryTheory.Triangulated.Functor | ∀ {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.HasShift C ℤ]
[inst_3 : CategoryTheory.HasShift D ℤ] (F : CategoryTheory.Functor C D) [inst_4 : F.CommShift ℤ]
[inst_5 : CategoryTheory.Preadditive C] [inst_6 : CategoryTheory.Preadditive D] [inst_7 : F.Additive] (n : ℤ)
(X : CategoryTheory.Pretriangulated.Triangle C),
((F.mapTriangleCommShiftIso n).inv.app X).hom₁ = (CategoryTheory.Functor.commShiftIso F n).inv.app X.obj₁ |
Nat.Partrec.Code.ofNatCode.eq_4 | Mathlib.Computability.PartrecCode | Nat.Partrec.Code.ofNatCode 3 = Nat.Partrec.Code.right |
_private.Init.Data.Int.DivMod.Lemmas.0.Int.fdiv_fmod_unique'._proof_1_1 | Init.Data.Int.DivMod.Lemmas | ∀ {b : ℤ}, b < 0 → ¬0 < -b → False |
Lean.Doc.Syntax.directive._regBuiltin.Lean.Doc.Syntax.directive.docString_1 | Lean.DocString.Syntax | IO Unit |
ArchimedeanClass.mk_nonneg_of_le_of_le_of_archimedean | Mathlib.Algebra.Order.Ring.Archimedean | ∀ {R : Type u_1} [inst : LinearOrder R] [inst_1 : CommRing R] [inst_2 : IsStrictOrderedRing R] {S : Type u_3}
[inst_3 : LinearOrder S] [inst_4 : CommRing S] [IsStrictOrderedRing S] [Archimedean S] (f : S →+*o R) {x : R}
{r s : S}, f r ≤ x → x ≤ f s → 0 ≤ ArchimedeanClass.mk x |
CommRingCat.Colimits.instCommRingColimitType._proof_9 | Mathlib.Algebra.Category.Ring.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.SmallCategory J] (F : CategoryTheory.Functor J CommRingCat)
(x : CommRingCat.Colimits.ColimitType F), 0 * x = 0 |
Quaternion.imJ_star | Mathlib.Algebra.Quaternion | ∀ {R : Type u_3} [inst : CommRing R] (a : Quaternion R), (star a).imJ = -a.imJ |
List.splitAtD.go._sunfold | Batteries.Data.List.Basic | {α : Type u_1} → α → ℕ → List α → List α → List α × List α |
Lean.Meta.LazyDiscrTree.recOn | Lean.Meta.LazyDiscrTree | {α : Type} →
{motive : Lean.Meta.LazyDiscrTree α → Sort u} →
(t : Lean.Meta.LazyDiscrTree α) →
((tries : Array (Lean.Meta.LazyDiscrTree.Trie α)) →
(roots : Std.HashMap Lean.Meta.LazyDiscrTree.Key Lean.Meta.LazyDiscrTree.TrieIndex) →
motive { tries := tries, roots := roots }) →
motive t |
Mathlib.Tactic.Ring.ringCleanupRef | Mathlib.Tactic.Ring.Basic | IO.Ref (Lean.Expr → Lean.MetaM Lean.Expr) |
VitaliFamily.FineSubfamilyOn.index | Mathlib.MeasureTheory.Covering.VitaliFamily | {X : Type u_1} →
[inst : PseudoMetricSpace X] →
{m0 : MeasurableSpace X} →
{μ : MeasureTheory.Measure X} →
{v : VitaliFamily μ} → {f : X → Set (Set X)} → {s : Set X} → v.FineSubfamilyOn f s → Set (X × Set X) |
SimpleGraph.Walk.IsHamiltonian.fintype._proof_1 | Mathlib.Combinatorics.SimpleGraph.Hamiltonian | ∀ {α : Type u_1} [inst : DecidableEq α] {G : SimpleGraph α} {a b : α} {p : G.Walk a b},
p.IsHamiltonian → ∀ (x : α), x ∈ p.support.toFinset |
_private.Lean.Elab.DocString.Builtin.0.Lean.Doc.suggestName.match_4 | Lean.Elab.DocString.Builtin | (motive : Lean.Exception → Sort u_1) → (ex : Lean.Exception) → ((x : Lean.Exception) → motive x) → motive ex |
Nat.odd_sub._simp_1 | Mathlib.Algebra.Ring.Parity | ∀ {m n : ℕ}, n ≤ m → Odd (m - n) = (Odd m ↔ Even n) |
CategoryTheory.Functor.elementsFunctor_map | Mathlib.CategoryTheory.Elements | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : CategoryTheory.Functor C (Type w)} (n : X ⟶ Y),
CategoryTheory.Functor.elementsFunctor.map n = (CategoryTheory.NatTrans.mapElements n).toCatHom |
WithZeroMulInt.toNNReal_le_one_iff | Mathlib.Data.Int.WithZero | ∀ {e : NNReal} {m : WithZero (Multiplicative ℤ)} (he : 1 < e), (WithZeroMulInt.toNNReal ⋯) m ≤ 1 ↔ m ≤ 1 |
Algebra.transcendental_ringHom_iff_of_comp_eq | Mathlib.RingTheory.Algebraic.Basic | ∀ {R : Type u} {S : Type u_1} {A : Type v} [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : Ring A]
[inst_3 : Algebra R A] {B : Type u_2} [inst_4 : Ring B] [inst_5 : Algebra S B] {FRS : Type u_3} {FAB : Type u_4}
[inst_6 : EquivLike FRS R S] [inst_7 : RingEquivClass FRS R S] [inst_8 : EquivLike FAB A B]
[inst_9 : RingEquivClass FAB A B] (f : FRS) (g : FAB),
(algebraMap S B).comp ↑f = (↑g).comp (algebraMap R A) → (Algebra.Transcendental S B ↔ Algebra.Transcendental R A) |
padicValRat.of_int | Mathlib.NumberTheory.Padics.PadicVal.Basic | ∀ {p : ℕ} {z : ℤ}, padicValRat p ↑z = ↑(padicValInt p z) |
orderBornology_isBounded._simp_1 | Mathlib.Topology.Order.Bornology | ∀ {α : Type u_1} {s : Set α} [inst : Lattice α] [inst_1 : Nonempty α], Bornology.IsBounded s = (BddBelow s ∧ BddAbove s) |
Std.Tactic.BVDecide.LRAT.Internal.Formula.rupAdd_sound | Std.Tactic.BVDecide.LRAT.Internal.Formula.Class | ∀ {α : outParam (Type u)} {β : outParam (Type v)} {inst : Std.Tactic.BVDecide.LRAT.Internal.Clause α β} {σ : Type w}
{inst_1 : Std.Tactic.BVDecide.LRAT.Internal.Entails α σ} [self : Std.Tactic.BVDecide.LRAT.Internal.Formula α β σ]
(f : σ) (c : β) (rupHints : Array ℕ) (f' : σ),
Std.Tactic.BVDecide.LRAT.Internal.Formula.ReadyForRupAdd f →
Std.Tactic.BVDecide.LRAT.Internal.Formula.performRupAdd f c rupHints = (f', true) →
Std.Tactic.BVDecide.LRAT.Internal.Liff α f f' |
CategoryTheory.Precoherent.recOn | Mathlib.CategoryTheory.Sites.Coherent.Basic | {C : Type u_1} →
[inst : CategoryTheory.Category.{v_1, u_1} C] →
{motive : CategoryTheory.Precoherent C → Sort u} →
(t : CategoryTheory.Precoherent C) →
((pullback :
∀ {B₁ B₂ : C} (f : B₂ ⟶ B₁) (α : Type) [Finite α] (X₁ : α → C) (π₁ : (a : α) → X₁ a ⟶ B₁),
CategoryTheory.EffectiveEpiFamily X₁ π₁ →
∃ β,
∃ (_ : Finite β),
∃ X₂ π₂,
CategoryTheory.EffectiveEpiFamily X₂ π₂ ∧
∃ i ι,
∀ (b : β),
CategoryTheory.CategoryStruct.comp (ι b) (π₁ (i b)) =
CategoryTheory.CategoryStruct.comp (π₂ b) f) →
motive ⋯) →
motive t |
max_mul_mul_left | Mathlib.Algebra.Order.Monoid.Unbundled.MinMax | ∀ {α : Type u_1} [inst : LinearOrder α] [inst_1 : Mul α] [MulLeftMono α] (a b c : α), max (a * b) (a * c) = a * max b c |
ProbabilityTheory.Kernel.ae_compProd_iff | Mathlib.Probability.Kernel.Composition.CompProd | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {mα : MeasurableSpace α} {mβ : MeasurableSpace β}
{mγ : MeasurableSpace γ} {κ : ProbabilityTheory.Kernel α β} [ProbabilityTheory.IsSFiniteKernel κ]
{η : ProbabilityTheory.Kernel (α × β) γ} [ProbabilityTheory.IsSFiniteKernel η] {a : α} {p : β × γ → Prop},
MeasurableSet {x | p x} →
((∀ᵐ (bc : β × γ) ∂(κ.compProd η) a, p bc) ↔ ∀ᵐ (b : β) ∂κ a, ∀ᵐ (c : γ) ∂η (a, b), p (b, c)) |
Equiv.forall_congr' | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {p : α → Prop} {q : β → Prop} (e : α ≃ β),
(∀ (b : β), p (e.symm b) ↔ q b) → ((∀ (a : α), p a) ↔ ∀ (b : β), q b) |
CategoryTheory.congr_app | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} {α β : CategoryTheory.NatTrans F G}, α = β → ∀ (X : C), α.app X = β.app X |
Fintype.linearIndependent_iffₛ | Mathlib.LinearAlgebra.LinearIndependent.Defs | ∀ {ι : Type u'} {R : Type u_2} {M : Type u_4} {v : ι → M} [inst : Semiring R] [inst_1 : AddCommMonoid M]
[inst_2 : Module R M] [inst_3 : Fintype ι],
LinearIndependent R v ↔ ∀ (f g : ι → R), ∑ i, f i • v i = ∑ i, g i • v i → ∀ (i : ι), f i = g i |
CategoryTheory.Functor.PreservesLeftKanExtension.mk._flat_ctor | Mathlib.CategoryTheory.Functor.KanExtension.Preserves | ∀ {A : Type u_1} {B : Type u_2} {C : Type u_3} {D : Type u_4} [inst : CategoryTheory.Category.{v_1, u_1} A]
[inst_1 : CategoryTheory.Category.{v_2, u_2} B] [inst_2 : CategoryTheory.Category.{v_3, u_3} C]
[inst_3 : CategoryTheory.Category.{v_4, u_4} D] {G : CategoryTheory.Functor B D} {F : CategoryTheory.Functor A B}
{L : CategoryTheory.Functor A C},
(∀ (F' : CategoryTheory.Functor C B) (α : F ⟶ L.comp F') [F'.IsLeftKanExtension α],
(F'.comp G).IsLeftKanExtension
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight α G) (L.associator F' G).hom)) →
G.PreservesLeftKanExtension F L |
_private.Mathlib.Data.List.Cycle.0.List.next_eq_getElem._proof_1_7 | Mathlib.Data.List.Cycle | ∀ {α : Type u_1} [inst : DecidableEq α] {l : List α} {a : α},
a ∈ l →
∀ (hl : l ≠ []),
¬(List.idxOf a l + 1) % l.length + 1 ≤ l.dropLast.length →
(List.idxOf a l + 1) % l.length - l.dropLast.length < [l.getLast ⋯].length |
_private.Mathlib.Algebra.IsPrimePow.0.not_isPrimePow_zero._simp_1_4 | Mathlib.Algebra.IsPrimePow | ∀ {a b c : Prop}, (a ∧ b → c) = (a → b → c) |
AlgebraicGeometry.Scheme.Cover.ColimitGluingData.cocone_ι_transitionMap_assoc | Mathlib.AlgebraicGeometry.ColimitsOver | ∀ {P : CategoryTheory.MorphismProperty AlgebraicGeometry.Scheme} [inst : P.IsStableUnderBaseChange]
[inst_1 : P.IsMultiplicative] {S : AlgebraicGeometry.Scheme} {J : Type u_1}
[inst_2 : CategoryTheory.Category.{v_1, u_1} J] {D : CategoryTheory.Functor J (P.Over ⊤ S)} {𝒰 : S.OpenCover}
[inst_3 : CategoryTheory.Category.{v_2, u_2} 𝒰.I₀] [inst_4 : AlgebraicGeometry.Scheme.Cover.LocallyDirected 𝒰]
(d : AlgebraicGeometry.Scheme.Cover.ColimitGluingData D 𝒰) {i j : 𝒰.I₀} (hij : i ⟶ j) (a : J) {Z : P.Over ⊤ (𝒰.X j)}
(h : (d.cocone j).pt ⟶ Z),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.MorphismProperty.Over.map ⊤ ⋯).map ((d.cocone i).ι.app a))
(CategoryTheory.CategoryStruct.comp (d.transitionMap hij) h) =
CategoryTheory.CategoryStruct.comp ((d.trans hij).app a)
(CategoryTheory.CategoryStruct.comp ((d.cocone j).ι.app a) h) |
Real.expPartialHomeomorph_target | Mathlib.Analysis.SpecialFunctions.Log.Basic | Real.expPartialHomeomorph.target = Set.Ioi 0 |
IsCompl.compl_eq_iff | Mathlib.Order.BooleanAlgebra.Basic | ∀ {α : Type u} {x y z : α} [inst : BooleanAlgebra α], IsCompl x y → (zᶜ = y ↔ z = x) |
Array.all_iff_forall | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {p : α → Bool} {as : Array α} {start stop : ℕ},
as.all p start stop = true ↔ ∀ (i : ℕ) (x : i < as.size), start ≤ i ∧ i < stop → p as[i] = true |
AddAction.sigmaFixedByEquivOrbitsProdAddGroup._proof_1 | Mathlib.GroupTheory.GroupAction.Quotient | ∀ (α : Type u_1) (β : Type u_2) [inst : AddGroup α] [inst_1 : AddAction α β] (x : α × β),
x.1 +ᵥ x.2 = x.2 ↔ x.1 +ᵥ x.2 = x.2 |
_private.Mathlib.Data.Rat.Sqrt.0.Rat.exists_mul_self.match_1_1 | Mathlib.Data.Rat.Sqrt | ∀ (x : ℚ) (motive : (∃ q, q * q = x) → Prop) (x_1 : ∃ q, q * q = x), (∀ (n : ℚ) (hn : n * n = x), motive ⋯) → motive x_1 |
Mathlib.Tactic._aux_Mathlib_Tactic_Core___macroRules_Mathlib_Tactic_tacticRepeat1__1 | Mathlib.Tactic.Core | Lean.Macro |
HahnSeries.toOrderTopSubOnePos | Mathlib.RingTheory.HahnSeries.Summable | {Γ : Type u_1} →
{R : Type u_3} →
[inst : AddCommMonoid Γ] →
[inst_1 : LinearOrder Γ] →
[inst_2 : IsOrderedCancelAddMonoid Γ] →
[inst_3 : CommRing R] → {x : HahnSeries Γ R} → 0 < (x - 1).orderTop → ↥(HahnSeries.orderTopSubOnePos Γ R) |
infEDist_inv | Mathlib.Analysis.Normed.Group.Pointwise | ∀ {E : Type u_1} [inst : SeminormedCommGroup E] (x : E) (s : Set E), Metric.infEDist x⁻¹ s = Metric.infEDist x s⁻¹ |
instBornologyPUnit._proof_1 | Mathlib.Topology.Bornology.Basic | ⊥ ≤ Filter.cofinite |
Lean.SerialMessage.ctorIdx | Lean.Message | Lean.SerialMessage → ℕ |
Char.lt | Init.Data.Char.Basic | Char → Char → Prop |
Lean.Grind.CommRing.Stepwise.div_cert.eq_1 | Init.Grind.Ring.CommSolver | ∀ (p₁ : Lean.Grind.CommRing.Poly) (k : ℤ) (p : Lean.Grind.CommRing.Poly),
Lean.Grind.CommRing.Stepwise.div_cert p₁ k p = (!k.beq' 0).and' ((Lean.Grind.CommRing.Poly.mulConst_k k p).beq' p₁) |
_private.Lean.Shell.0.Lean.displayHelp | Lean.Shell | Bool → IO Unit |
_private.Mathlib.FieldTheory.AlgebraicClosure.0.le_algebraicClosure_iff._simp_1_1 | Mathlib.FieldTheory.AlgebraicClosure | ∀ {F : Type u_1} {E : Type u_2} [inst : Field F] [inst_1 : Field E] [inst_2 : Algebra F E] {x : E},
(x ∈ algebraicClosure F E) = IsAlgebraic F x |
_private.Mathlib.Topology.CWComplex.Classical.Basic.0.Topology.RelCWComplex.disjoint_base_iUnion_openCell._simp_1_2 | Mathlib.Topology.CWComplex.Classical.Basic | ∀ {α : Type u_1} {ι : Sort u_5} {s : ι → Set α}, (⋃ i, s i = ∅) = ∀ (i : ι), s i = ∅ |
Array.forIn' | Init.Data.Array.Basic | {α : Type u} →
{β : Type v} → {m : Type v → Type w} → [Monad m] → (as : Array α) → β → ((a : α) → a ∈ as → β → m (ForInStep β)) → m β |
Std.ExtDTreeMap.Const.getEntryLT._proof_1 | Std.Data.ExtDTreeMap.Basic | ∀ {α : Type u_1} {cmp : α → α → Ordering} {β : Type u_2} [inst : Std.TransCmp cmp]
(t : Std.ExtDTreeMap α (fun x => β) cmp) (k : α),
(∃ a ∈ t, cmp a k = Ordering.lt) →
∀ (m : Std.DTreeMap α (fun x => β) cmp),
t = Std.ExtDTreeMap.mk m → ∃ a ∈ Std.ExtDTreeMap.mk m, cmp a k = Ordering.lt |
Real.logb_neg_of_base_lt_one | Mathlib.Analysis.SpecialFunctions.Log.Base | ∀ {b x : ℝ}, 0 < b → b < 1 → 1 < x → Real.logb b x < 0 |
CategoryTheory.equivEssImageOfReflective_inverse | Mathlib.CategoryTheory.Adjunction.Reflective | ∀ {C : Type u₁} {D : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} C] [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{i : CategoryTheory.Functor D C} [inst_2 : CategoryTheory.Reflective i],
CategoryTheory.equivEssImageOfReflective.inverse = i.essImage.ι.comp (CategoryTheory.reflector i) |
AddEquiv.mk.sizeOf_spec | Mathlib.Algebra.Group.Equiv.Defs | ∀ {A : Type u_9} {B : Type u_10} [inst : Add A] [inst_1 : Add B] [inst_2 : SizeOf A] [inst_3 : SizeOf B]
(toEquiv : A ≃ B) (map_add' : ∀ (x y : A), toEquiv.toFun (x + y) = toEquiv.toFun x + toEquiv.toFun y),
sizeOf { toEquiv := toEquiv, map_add' := map_add' } = 1 + sizeOf toEquiv |
HomotopicalAlgebra.LeftHomotopyRel.postcomp | Mathlib.AlgebraicTopology.ModelCategory.LeftHomotopy | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y : C}
[inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C] {f g : X ⟶ Y},
HomotopicalAlgebra.LeftHomotopyRel f g →
∀ {Z : C} (p : Y ⟶ Z),
HomotopicalAlgebra.LeftHomotopyRel (CategoryTheory.CategoryStruct.comp f p)
(CategoryTheory.CategoryStruct.comp g p) |
_private.Init.Data.String.Basic.0.String.Pos.toSlice_le._simp_1_1 | Init.Data.String.Basic | ∀ {s : String.Slice} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) |
HomologicalComplex₂.D₁_totalShift₂XIso_hom | Mathlib.Algebra.Homology.TotalComplexShift | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Preadditive C]
(K : HomologicalComplex₂ C (ComplexShape.up ℤ) (ComplexShape.up ℤ)) (y : ℤ) [inst_2 : K.HasTotal (ComplexShape.up ℤ)]
(n₀ n₁ n₀' n₁' : ℤ) (h₀ : n₀ + y = n₀') (h₁ : n₁ + y = n₁'),
CategoryTheory.CategoryStruct.comp (((HomologicalComplex₂.shiftFunctor₂ C y).obj K).D₁ (ComplexShape.up ℤ) n₀ n₁)
(K.totalShift₂XIso y n₁ n₁' h₁).hom =
y.negOnePow •
CategoryTheory.CategoryStruct.comp (K.totalShift₂XIso y n₀ n₀' h₀).hom (K.D₁ (ComplexShape.up ℤ) n₀' n₁') |
ByteArray.extract_eq_empty_iff | Init.Data.ByteArray.Lemmas | ∀ {b : ByteArray} {i j : ℕ}, b.extract i j = ByteArray.empty ↔ min j b.size ≤ i |
_private.Mathlib.RingTheory.Ideal.GoingUp.0.Ideal.IsIntegralClosure.comap_ne_bot.match_1_1 | Mathlib.RingTheory.Ideal.GoingUp | ∀ {A : Type u_1} [inst : CommRing A] {I : Ideal A} (motive : (∃ x ∈ I, x ≠ 0) → Prop) (x : ∃ x ∈ I, x ≠ 0),
(∀ (x : A) (x_mem : x ∈ I) (x_ne_zero : x ≠ 0), motive ⋯) → motive x |
Lean.instInhabitedAuxParentProjectionInfo.default | Lean.ProjFns | Lean.AuxParentProjectionInfo |
_private.Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension.0.IsOpen.exists_contDiff_support_eq._simp_1_1 | Mathlib.Analysis.Calculus.BumpFunction.FiniteDimension | ∀ {α : Type u} {a : α} {s : Set α}, ({a} ⊆ s) = (a ∈ s) |
_private.Aesop.Forward.State.0.Aesop.instBEqRawHyp.beq.match_1 | Aesop.Forward.State | (motive : Aesop.RawHyp → Aesop.RawHyp → Sort u_1) →
(x x_1 : Aesop.RawHyp) →
((a b : Lean.FVarId) → motive (Aesop.RawHyp.fvarId a) (Aesop.RawHyp.fvarId b)) →
((a b : Aesop.Substitution) → motive (Aesop.RawHyp.patSubst a) (Aesop.RawHyp.patSubst b)) →
((x x_2 : Aesop.RawHyp) → motive x x_2) → motive x x_1 |
CategoryTheory.Monad.id._proof_1 | Mathlib.CategoryTheory.Monad.Basic | ∀ (C : Type u_2) [inst : CategoryTheory.Category.{u_1, u_2} C] (X : C),
CategoryTheory.CategoryStruct.comp
((CategoryTheory.Functor.id C).map ((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X))
((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X) =
CategoryTheory.CategoryStruct.comp
((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app ((CategoryTheory.Functor.id C).obj X))
((CategoryTheory.CategoryStruct.id (CategoryTheory.Functor.id C)).app X) |
ProbabilityTheory.IndepFun.map_mul_eq_map_mconv_map₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_7} {mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {M : Type u_10} [inst : Monoid M]
[inst_1 : MeasurableSpace M] [MeasurableMul₂ M] [MeasureTheory.IsFiniteMeasure μ] {f g : Ω → M},
AEMeasurable f μ →
AEMeasurable g μ →
ProbabilityTheory.IndepFun f g μ →
MeasureTheory.Measure.map (f * g) μ = (MeasureTheory.Measure.map f μ).mconv (MeasureTheory.Measure.map g μ) |
multiplicity_addValuation_apply | Mathlib.RingTheory.Valuation.PrimeMultiplicity | ∀ {R : Type u_1} [inst : CommRing R] [inst_1 : IsDomain R] {p : R} {hp : Prime p} {r : R},
(multiplicity_addValuation hp) r = emultiplicity p r |
ContDiffAt.exists_forall_mem_closedBall_exists_eq_forall_mem_Ioo_hasDerivAt | Mathlib.Analysis.ODE.PicardLindelof | ∀ {E : Type u_1} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [CompleteSpace E] {f : E → E} {x₀ : E},
ContDiffAt ℝ 1 f x₀ →
∀ (t₀ : ℝ),
∃ r > 0,
∃ ε > 0, ∀ x ∈ Metric.closedBall x₀ r, ∃ α, α t₀ = x ∧ ∀ t ∈ Set.Ioo (t₀ - ε) (t₀ + ε), HasDerivAt α (f (α t)) t |
Path.Homotopy.transAssoc._proof_4 | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ⟨Path.Homotopy.transAssocReparamAux 1, Path.Homotopy.transAssoc._proof_3⟩ = 1 |
Std.Tactic.BVDecide.Normalize.BitVec.beq_one_eq_ite' | Std.Tactic.BVDecide.Normalize.Bool | ∀ {b : Bool} {a : BitVec 1}, (b == (a == 1#1)) = (a == bif b then 1#1 else 0#1) |
HasFibers.instFaithfulFibι | Mathlib.CategoryTheory.FiberedCategory.HasFibers | ∀ {𝒮 : Type u₁} {𝒳 : Type u₂} [inst : CategoryTheory.Category.{v₁, u₁} 𝒮] [inst_1 : CategoryTheory.Category.{v₂, u₂} 𝒳]
(p : CategoryTheory.Functor 𝒳 𝒮) [inst_2 : HasFibers p] (S : 𝒮), (HasFibers.ι S).Faithful |
CategoryTheory.InjectiveResolution.toRightDerivedZero'._proof_2 | Mathlib.CategoryTheory.Abelian.RightDerived | ∀ {C : Type u_4} [inst : CategoryTheory.Category.{u_3, u_4} C] {D : Type u_2}
[inst_1 : CategoryTheory.Category.{u_1, u_2} D] [inst_2 : CategoryTheory.Abelian C]
[inst_3 : CategoryTheory.Abelian D] {X : C} (P : CategoryTheory.InjectiveResolution X)
(F : CategoryTheory.Functor C D) [inst_4 : F.Additive],
CategoryTheory.CategoryStruct.comp (F.map (P.ι.f 0))
(((F.mapHomologicalComplex (ComplexShape.up ℕ)).obj P.cocomplex).d 0 1) =
0 |
CategoryTheory.ParametrizedAdjunction.rec | Mathlib.CategoryTheory.Adjunction.Parametrized | {C₁ : Type u₁} →
{C₂ : Type u₂} →
{C₃ : Type u₃} →
[inst : CategoryTheory.Category.{v₁, u₁} C₁] →
[inst_1 : CategoryTheory.Category.{v₂, u₂} C₂] →
[inst_2 : CategoryTheory.Category.{v₃, u₃} C₃] →
{F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂ C₃)} →
{G : CategoryTheory.Functor C₁ᵒᵖ (CategoryTheory.Functor C₃ C₂)} →
{motive : (F ⊣₂ G) → Sort u} →
((adj : (X₁ : C₁) → F.obj X₁ ⊣ G.obj (Opposite.op X₁)) →
(unit_whiskerRight_map :
∀ {X₁ Y₁ : C₁} (f : X₁ ⟶ Y₁),
CategoryTheory.CategoryStruct.comp (adj X₁).unit
(CategoryTheory.Functor.whiskerRight (F.map f) (G.obj (Opposite.op X₁))) =
CategoryTheory.CategoryStruct.comp (adj Y₁).unit ((F.obj Y₁).whiskerLeft (G.map f.op))) →
motive { adj := adj, unit_whiskerRight_map := unit_whiskerRight_map }) →
(t : F ⊣₂ G) → motive t |
Turing.PartrecToTM2.tr.eq_2 | Mathlib.Computability.TMToPartrec | ∀ (k : Turing.PartrecToTM2.K') (f : Option Turing.PartrecToTM2.Γ' → Option Turing.PartrecToTM2.Γ')
(q : Turing.PartrecToTM2.Λ'),
Turing.PartrecToTM2.tr (Turing.PartrecToTM2.Λ'.push k f q) =
Turing.TM2.Stmt.branch (fun s => (f s).isSome)
(Turing.TM2.Stmt.push k (fun s => (f s).getD default) (Turing.TM2.Stmt.goto fun x => q))
(Turing.TM2.Stmt.goto fun x => q) |
Std.DTreeMap.getKeyD_minKey! | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[inst : Inhabited α], t.isEmpty = false → ∀ {fallback : α}, t.getKeyD t.minKey! fallback = t.minKey! |
PMF.seq.eq_1 | Mathlib.Probability.ProbabilityMassFunction.Constructions | ∀ {α : Type u_1} {β : Type u_2} (q : PMF (α → β)) (p : PMF α), q.seq p = q.bind fun m => p.bind fun a => PMF.pure (m a) |
Lean.Elab.Tactic.BVDecide.Frontend.SolverMode._sizeOf_1 | Std.Tactic.BVDecide.Syntax | Lean.Elab.Tactic.BVDecide.Frontend.SolverMode → ℕ |
Equiv.addEquiv._proof_1 | Mathlib.Algebra.Group.TransferInstance | ∀ {α : Type u_2} {β : Type u_1} (e : α ≃ β) [inst : Add β] (x y : α), e.toFun (x + y) = e.toFun x + e.toFun y |
SupIrred.ne_bot | Mathlib.Order.Irreducible | ∀ {α : Type u_2} [inst : SemilatticeSup α] {a : α} [inst_1 : OrderBot α], SupIrred a → a ≠ ⊥ |
HomologicalComplex.mapBifunctor₂₃.d₃_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₂₃ : Type u_4} {C₃ : Type u_5} {C₄ : Type u_6}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_5} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_6} C₄]
[inst_4 : CategoryTheory.Category.{v_6, u_4} C₂₃] [inst_5 : CategoryTheory.Limits.HasZeroMorphisms C₁]
[inst_6 : CategoryTheory.Limits.HasZeroMorphisms C₂] [inst_7 : CategoryTheory.Limits.HasZeroMorphisms C₃]
[inst_8 : CategoryTheory.Preadditive C₂₃] [inst_9 : CategoryTheory.Preadditive C₄]
(F : CategoryTheory.Functor C₁ (CategoryTheory.Functor C₂₃ C₄))
(G₂₃ : CategoryTheory.Functor C₂ (CategoryTheory.Functor C₃ C₂₃)) [inst_10 : G₂₃.PreservesZeroMorphisms]
[inst_11 : ∀ (X₂ : C₂), (G₂₃.obj X₂).PreservesZeroMorphisms] [inst_12 : F.PreservesZeroMorphisms]
[inst_13 : ∀ (X₁ : C₁), (F.obj X₁).Additive] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9} {ι₁₂ : Type u_10}
{ι₂₃ : Type u_11} {ι₄ : Type u_12} [inst_14 : DecidableEq ι₄] {c₁ : ComplexShape ι₁} {c₂ : ComplexShape ι₂}
{c₃ : ComplexShape ι₃} (K₁ : HomologicalComplex C₁ c₁) (K₂ : HomologicalComplex C₂ c₂) (K₃ : HomologicalComplex C₃ c₃)
(c₁₂ : ComplexShape ι₁₂) (c₂₃ : ComplexShape ι₂₃) (c₄ : ComplexShape ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : TotalComplexShape c₂ c₃ c₂₃]
[inst_18 : TotalComplexShape c₁ c₂₃ c₄] [inst_19 : K₂.HasMapBifunctor K₃ G₂₃ c₂₃]
[inst_20 : c₁.Associative c₂ c₃ c₁₂ c₂₃ c₄] [inst_21 : DecidableEq ι₂₃]
[inst_22 : K₁.HasMapBifunctor (K₂.mapBifunctor K₃ G₂₃ c₂₃) F c₄] (i₁ : ι₁) (i₂ : ι₂) {i₃ i₃' : ι₃},
c₃.Rel i₃ i₃' → ∀ (j : ι₄), ⋯ = ⋯ |
Set.nonempty_sInter._simp_1 | Mathlib.Data.Set.Lattice | ∀ {α : Type u_1} {c : Set (Set α)}, (⋂₀ c).Nonempty = ∃ a, ∀ b ∈ c, a ∈ b |
_private.Mathlib.RingTheory.Valuation.ValuationSubring.0.ValuationSubring.ofPrime_idealOfLE._simp_1_2 | Mathlib.RingTheory.Valuation.ValuationSubring | ∀ {M : Type u_1} [inst : MulOneClass M] {s : Subsemigroup M} {x : M} (h_one : 1 ∈ s.carrier),
(x ∈ { toSubsemigroup := s, one_mem' := h_one }) = (x ∈ s) |
DirSupInaccOn | Mathlib.Topology.Order.ScottTopology | {α : Type u_1} → [Preorder α] → Set (Set α) → Set α → Prop |
extDeriv_apply_vectorField_of_pairwise_commute | Mathlib.Analysis.Calculus.DifferentialForm.VectorField | ∀ {𝕜 : Type u_1} {E : Type u_2} {F : Type u_3} [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : ℕ} {x : E}
{ω : E → E [⋀^Fin n]→L[𝕜] F} {V : Fin (n + 1) → E → E},
DifferentiableAt 𝕜 ω x →
(∀ (i : Fin (n + 1)), DifferentiableAt 𝕜 (V i) x) →
(Pairwise fun i j => VectorField.lieBracket 𝕜 (V i) (V j) x = 0) →
((extDeriv ω x) fun x_1 => V x_1 x) =
∑ i, (-1) ^ ↑i • (fderiv 𝕜 (fun x => (ω x) (i.removeNth fun x_1 => V x_1 x)) x) (V i x) |
BitVec.toNat_cpop_concat | Init.Data.BitVec.Lemmas | ∀ {w : ℕ} {x : BitVec w} {b : Bool}, (x.concat b).cpop.toNat = b.toNat + x.cpop.toNat |
Polynomial.recOnHorner._unary._proof_15 | Mathlib.Algebra.Polynomial.Inductions | ∀ {R : Type u_2} [inst : Semiring R] {M : Polynomial R → Sort u_1} (p : Polynomial R),
M (p.divX * Polynomial.X + Polynomial.C 0) = M (p.divX * Polynomial.X + 0) |
Aesop.instInhabitedNormalizationState.default | Aesop.Tree.Data | Aesop.NormalizationState |
_private.Std.Data.DHashMap.Lemmas.0.Std.DHashMap.mem_alter._simp_1_1 | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.DHashMap α β} {a : α},
(a ∈ m) = (m.contains a = true) |
DifferentiableOn.mul_const | Mathlib.Analysis.Calculus.FDeriv.Mul | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {s : Set E} {𝔸 : Type u_5} [inst_3 : NormedRing 𝔸] [inst_4 : NormedAlgebra 𝕜 𝔸]
{a : E → 𝔸}, DifferentiableOn 𝕜 a s → ∀ (b : 𝔸), DifferentiableOn 𝕜 (fun y => a y * b) s |
CategoryTheory.Limits.KernelFork.IsLimit.ofιUnop._proof_4 | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Kernels | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
{K X Y : Cᵒᵖ} (i : K ⟶ X) {f : X ⟶ Y} (w : CategoryTheory.CategoryStruct.comp i f = 0)
(h : CategoryTheory.Limits.IsLimit (CategoryTheory.Limits.KernelFork.ofι i w)) {Z' : C} (x : Opposite.unop X ⟶ Z')
(x_1 : CategoryTheory.CategoryStruct.comp f.unop x = 0),
CategoryTheory.CategoryStruct.comp i.unop (h.lift (CategoryTheory.Limits.KernelFork.ofι x.op ⋯)).unop = x |
FiniteField.frobeniusAlgEquiv._proof_1 | Mathlib.FieldTheory.Finite.Basic | ∀ (K : Type u_2) (R : Type u_1) [inst : Field K] [inst_1 : Fintype K] [inst_2 : CommRing R] [inst_3 : Algebra K R]
(p : ℕ) [inst_4 : ExpChar R p] [PerfectRing R p], Function.Bijective ⇑(FiniteField.frobeniusAlgHom K R) |
UniformSpace.Completion.extensionHom._proof_2 | Mathlib.Topology.Algebra.UniformRing | ∀ {α : Type u_2} [inst : Ring α] {β : Type u_1} [inst_1 : Ring β], AddMonoidHomClass (α →+* β) α β |
_private.Batteries.Data.List.Lemmas.0.List.pos_findIdxNth_getElem._proof_1_12 | Batteries.Data.List.Lemmas | ∀ {α : Type u_1} {p : α → Bool} (tail : List α) {n : ℕ},
List.findIdxNth p tail (n - 1) + 1 ≤ tail.length → List.findIdxNth p tail (n - 1) < tail.length |
_private.Lean.Data.FuzzyMatching.0.Lean.FuzzyMatching.Score | Lean.Data.FuzzyMatching | Type |
_private.Qq.Macro.0.Qq.Impl.quoteExpr.match_1 | Qq.Macro | (motive : Qq.Impl.ExprBackSubstResult → Sort u_1) →
(r : Qq.Impl.ExprBackSubstResult) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.quoted r)) →
((r : Lean.Expr) → motive (Qq.Impl.ExprBackSubstResult.unquoted r)) → motive r |
FreeLieAlgebra.lift_of_apply | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {L : Type w} [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] (f : X → L)
(x : X), ((FreeLieAlgebra.lift R) f) (FreeLieAlgebra.of R x) = f x |
CategoryTheory.SplitMono | Mathlib.CategoryTheory.EpiMono | {C : Type u₁} → [inst : CategoryTheory.Category.{v₁, u₁} C] → {X Y : C} → (X ⟶ Y) → Type v₁ |
MDifferentiableWithinAt.prodMap' | Mathlib.Geometry.Manifold.MFDeriv.SpecificFunctions | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {H : Type u_3} [inst_3 : TopologicalSpace H] {I : ModelWithCorners 𝕜 E H} {M : Type u_4}
[inst_4 : TopologicalSpace M] [inst_5 : ChartedSpace H M] {E' : Type u_5} [inst_6 : NormedAddCommGroup E']
[inst_7 : NormedSpace 𝕜 E'] {H' : Type u_6} [inst_8 : TopologicalSpace H'] {I' : ModelWithCorners 𝕜 E' H'}
{M' : Type u_7} [inst_9 : TopologicalSpace M'] [inst_10 : ChartedSpace H' M'] {F : Type u_11}
[inst_11 : NormedAddCommGroup F] [inst_12 : NormedSpace 𝕜 F] {G : Type u_12} [inst_13 : TopologicalSpace G]
{J : ModelWithCorners 𝕜 F G} {N : Type u_13} [inst_14 : TopologicalSpace N] [inst_15 : ChartedSpace G N]
{F' : Type u_14} [inst_16 : NormedAddCommGroup F'] [inst_17 : NormedSpace 𝕜 F'] {G' : Type u_15}
[inst_18 : TopologicalSpace G'] {J' : ModelWithCorners 𝕜 F' G'} {N' : Type u_16} [inst_19 : TopologicalSpace N']
[inst_20 : ChartedSpace G' N'] {s : Set M} {f : M → M'} {g : N → N'} {r : Set N} {p : M × N},
MDifferentiableWithinAt I I' f s p.1 →
MDifferentiableWithinAt J J' g r p.2 → MDifferentiableWithinAt (I.prod J) (I'.prod J') (Prod.map f g) (s ×ˢ r) p |
CategoryTheory.Localization.Construction.morphismProperty_eq_top' | Mathlib.CategoryTheory.Localization.Construction | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] {W : CategoryTheory.MorphismProperty C}
(P : CategoryTheory.MorphismProperty W.Localization) [P.IsStableUnderComposition],
(∀ ⦃X Y : C⦄ (f : X ⟶ Y), P (W.Q.map f)) → (∀ ⦃X Y : W.Localization⦄ (e : X ≅ Y), P e.hom → P e.inv) → P = ⊤ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.