name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Std.IterM.forIn_toList | Init.Data.Iterators.Lemmas.Consumers.Monadic.Loop | ∀ {m : Type w → Type u_1} {γ α β : Type w} [inst : Monad m] [LawfulMonad m] [inst_2 : Std.Iterator α Id β]
[Std.Iterators.Finite α Id] [inst_4 : Std.IteratorLoop α Id m] [Std.LawfulIteratorLoop α Id m] {it : Std.IterM Id β}
{f : β → γ → m (ForInStep γ)} {init : γ}, forIn it.toList.run init f = forIn it init f |
Simps.AutomaticProjectionData.recOn | Mathlib.Tactic.Simps.NotationClass | {motive : Simps.AutomaticProjectionData → Sort u} →
(t : Simps.AutomaticProjectionData) →
((className : Lean.Name) →
(isNotation : Bool) →
(findArgs : Lean.Name) → motive { className := className, isNotation := isNotation, findArgs := findArgs }) →
motive t |
List.Cursor.pos_at | Std.Do.Triple.SpecLemmas | ∀ {α : Type u_1} {l : List α} {n : ℕ}, n < l.length → (List.Cursor.at l n).pos = n |
Lean.getPPPiBinderNamesHygienic | Lean.PrettyPrinter.Delaborator.Options | Lean.Options → Bool |
Finset.sum_range_diag_flip | Mathlib.Algebra.BigOperators.Intervals | ∀ {M : Type u_3} [inst : AddCommMonoid M] (n : ℕ) (f : ℕ → ℕ → M),
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (m + 1), f k (m - k) =
∑ m ∈ Finset.range n, ∑ k ∈ Finset.range (n - m), f m k |
String.Slice.Pattern.Char.instToForwardSearcherCharDefaultForwardSearcher | Init.Data.String.Pattern.Char | {c : Char} → String.Slice.Pattern.ToForwardSearcher c (String.Slice.Pattern.ToForwardSearcher.DefaultForwardSearcher c) |
Lean.Parser.Term.liftMethod | Lean.Parser.Do | Lean.Parser.Parser |
DiscreteUniformity.mk | Mathlib.Topology.UniformSpace.DiscreteUniformity | ∀ {X : Type u_1} [u : UniformSpace X], u = ⊥ → DiscreteUniformity X |
Representation.finsupp | Mathlib.RepresentationTheory.Basic | {k : Type u_1} →
{G : Type u_2} →
[inst : CommSemiring k] →
[inst_1 : Monoid G] →
{A : Type u_4} →
[inst_2 : AddCommMonoid A] →
[inst_3 : Module k A] → Representation k G A → (α : Type u_6) → Representation k G (α →₀ A) |
Std.DTreeMap.minKey?_eq_some_iff_mem_and_forall | Std.Data.DTreeMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {cmp : α → α → Ordering} {t : Std.DTreeMap α β cmp} [Std.TransCmp cmp]
[Std.LawfulEqCmp cmp] {km : α}, t.minKey? = some km ↔ km ∈ t ∧ ∀ k ∈ t, (cmp km k).isLE = true |
ConditionallyCompletePartialOrderSup.noConfusionType | Mathlib.Order.ConditionallyCompletePartialOrder.Defs | Sort u →
{α : Type u_3} →
ConditionallyCompletePartialOrderSup α → {α' : Type u_3} → ConditionallyCompletePartialOrderSup α' → Sort u |
ProofWidgets.Penrose.DiagramState.casesOn | ProofWidgets.Component.PenroseDiagram | {motive : ProofWidgets.Penrose.DiagramState → Sort u} →
(t : ProofWidgets.Penrose.DiagramState) →
((sub : String) →
(embeds : Std.HashMap String (String × ProofWidgets.Html)) → motive { sub := sub, embeds := embeds }) →
motive t |
_private.Mathlib.RingTheory.SimpleModule.Basic.0.IsSemisimpleModule.sSup_simples_le._simp_1_1 | Mathlib.RingTheory.SimpleModule.Basic | ∀ {R : Type u_2} [inst : Ring R] {M : Type u_4} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {m : Submodule R M},
IsSimpleModule R ↥m = IsAtom m |
Set.finite_iff_finite_of_encard_eq_encard | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α}, s.encard = t.encard → (s.Finite ↔ t.Finite) |
LipschitzOnWith.prodMk | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} {γ : Type w} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β]
[inst_2 : PseudoEMetricSpace γ] {s : Set α} {f : α → β} {g : α → γ} {Kf Kg : NNReal},
LipschitzOnWith Kf f s → LipschitzOnWith Kg g s → LipschitzOnWith (max Kf Kg) (fun x => (f x, g x)) s |
Lean.Meta.Hint.tryThisDiffWidget | Lean.Meta.Hint | Lean.Widget.Module |
NonarchAddGroupSeminorm.coe_iSup_apply | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_3} [inst : AddGroup E] {ι : Type u_6} (f : ι → NonarchAddGroupSeminorm E),
BddAbove (Set.range f) → ∀ {x : E}, (⨆ i, f i) x = ⨆ i, (f i) x |
Prod.mk_lt_mk_iff_right._gcongr_1 | Mathlib.Order.Basic | ∀ {α : Type u_2} {β : Type u_3} [inst : Preorder α] [inst_1 : Preorder β] {a : α} {b₁ b₂ : β},
b₁ < b₂ → (a, b₁) < (a, b₂) |
instIsSemisimpleModuleOfIsSimpleModule | Mathlib.RingTheory.SimpleModule.Basic | ∀ (R : Type u_2) [inst : Ring R] (M : Type u_4) [inst_1 : AddCommGroup M] [inst_2 : Module R M] [IsSimpleModule R M],
IsSemisimpleModule R M |
_private.Mathlib.Tactic.Ring.Compare.0.Mathlib.Tactic.Ring.proveLE.match_4 | Mathlib.Tactic.Ring.Compare | (motive : Option (Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) →
((α e₁ e₂ : Lean.Expr) → motive (some (α, e₁, e₂))) →
((x : Option (Lean.Expr × Lean.Expr × Lean.Expr)) → motive x) → motive x |
Orientation.kahler._proof_1 | Mathlib.Analysis.InnerProductSpace.TwoDim | SMulCommClass ℝ ℝ ℂ |
_private.Mathlib.GroupTheory.DoubleCoset.0.DoubleCoset.mem_doubleCoset_of_not_disjoint._simp_1_1 | Mathlib.GroupTheory.DoubleCoset | ∀ {α : Type u_2} [inst : Mul α] {s t : Set α} {a b : α},
(b ∈ DoubleCoset.doubleCoset a s t) = ∃ x ∈ s, ∃ y ∈ t, b = x * a * y |
Polynomial.modByMonic_eq_of_dvd_sub | Mathlib.Algebra.Polynomial.Div | ∀ {R : Type u} [inst : CommRing R] {p₁ p₂ q : Polynomial R}, q.Monic → q ∣ p₁ - p₂ → p₁ %ₘ q = p₂ %ₘ q |
_private.Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas.0.Std.Tactic.BVDecide.LRAT.Internal.DefaultFormula.readyForRatAdd_insert._proof_1_4 | Std.Tactic.BVDecide.LRAT.Internal.Formula.Lemmas | ∀ {n : ℕ} (i : ℕ), i + 1 ≤ { toList := [] }.size → i < { toList := [] }.size |
Char.utf8Size_eq_one_iff | Init.Data.String.Decode | ∀ {c : Char}, c.utf8Size = 1 ↔ c.val ≤ 127 |
Lean.Meta.Grind.TopSort.State.mk | Lean.Meta.Tactic.Grind.EqResolution | Std.HashSet Lean.Expr → Std.HashSet Lean.Expr → Array Lean.Expr → Lean.Meta.Grind.TopSort.State |
LinearMap.coe_smul | Mathlib.Algebra.Module.LinearMap.Defs | ∀ {R : Type u_1} {R₂ : Type u_3} {S : Type u_5} {M : Type u_8} {M₂ : Type u_10} [inst : Semiring R]
[inst_1 : Semiring R₂] [inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M]
[inst_5 : Module R₂ M₂] {σ₁₂ : R →+* R₂} [inst_6 : DistribSMul S M₂] [inst_7 : SMulCommClass R₂ S M₂] (a : S)
(f : M →ₛₗ[σ₁₂] M₂), ⇑(a • f) = a • ⇑f |
_private.Mathlib.Combinatorics.Matroid.Minor.Delete.0.Matroid.delete_delete._simp_1_1 | Mathlib.Combinatorics.Matroid.Minor.Delete | ∀ {α : Type u_1} {s t : Set α}, (s \ t ⊆ s) = True |
Module.ringKrullDim_quotient_add_one_of_mem_nonZeroDivisors | Mathlib.RingTheory.KrullDimension.Regular | ∀ {R : Type u_1} [inst : CommRing R] [IsNoetherianRing R] {r : R},
r ∈ nonZeroDivisors R →
∀ {p : Ideal R} [p.IsPrime],
↑p.height = ringKrullDim R → r ∈ p → ringKrullDim (R ⧸ Ideal.span {r}) + 1 = ringKrullDim R |
Lean.Server.Test.Runner.RunnerState.method | Lean.Server.Test.Runner | Lean.Server.Test.Runner.RunnerState → String |
Aesop.TreeRef.recOn | Aesop.Tree.Traversal | {motive : Aesop.TreeRef → Sort u} →
(t : Aesop.TreeRef) →
((gref : Aesop.GoalRef) → motive (Aesop.TreeRef.goal gref)) →
((rref : Aesop.RappRef) → motive (Aesop.TreeRef.rapp rref)) →
((cref : Aesop.MVarClusterRef) → motive (Aesop.TreeRef.mvarCluster cref)) → motive t |
CauSeq.const.congr_simp | Mathlib.Algebra.Order.CauSeq.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [inst_2 : IsStrictOrderedRing α]
[inst_3 : Ring β] (abv : β → α) [inst_4 : IsAbsoluteValue abv] (x x_1 : β),
x = x_1 → CauSeq.const abv x = CauSeq.const abv x_1 |
HomologicalComplex.mapBifunctor₁₂.ι_eq | Mathlib.Algebra.Homology.BifunctorAssociator | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₁₂ : Type u_3} {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_5, u_3} 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 : F₁₂.PreservesZeroMorphisms]
[inst_11 : ∀ (X₁ : C₁), (F₁₂.obj X₁).PreservesZeroMorphisms] [inst_12 : G.Additive]
[inst_13 : ∀ (X₁₂ : C₁₂), (G.obj X₁₂).PreservesZeroMorphisms] {ι₁ : Type u_7} {ι₂ : Type u_8} {ι₃ : Type u_9}
{ι₁₂ : Type u_10} {ι₄ : 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 ι₄) [inst_15 : TotalComplexShape c₁ c₂ c₁₂]
[inst_16 : TotalComplexShape c₁₂ c₃ c₄] [inst_17 : K₁.HasMapBifunctor K₂ F₁₂ c₁₂] [inst_18 : DecidableEq ι₁₂]
[inst_19 : (K₁.mapBifunctor K₂ F₁₂ c₁₂).HasMapBifunctor K₃ G c₄] (i₁ : ι₁) (i₂ : ι₂) (i₃ : ι₃) (i₁₂ : ι₁₂) (j : ι₄)
(h₁₂ : c₁.π c₂ c₁₂ (i₁, i₂) = i₁₂) (h : c₁₂.π c₃ c₄ (i₁₂, i₃) = j),
HomologicalComplex.mapBifunctor₁₂.ι F₁₂ G K₁ K₂ K₃ c₁₂ c₄ i₁ i₂ i₃ j ⋯ =
CategoryTheory.CategoryStruct.comp ((G.map ⋯).app (K₃.X i₃))
((K₁.mapBifunctor K₂ F₁₂ c₁₂).ιMapBifunctor K₃ G c₄ i₁₂ i₃ j h) |
Std.Net.instDecidableEqIPv4Addr.decEq.match_1 | Std.Net.Addr | (motive : Std.Net.IPv4Addr → Std.Net.IPv4Addr → Sort u_1) →
(x x_1 : Std.Net.IPv4Addr) → ((a b : Vector UInt8 4) → motive { octets := a } { octets := b }) → motive x x_1 |
omegaToLiaRegressions | Mathlib.Tactic.TacticAnalysis.Declarations | Mathlib.TacticAnalysis.Config |
CantorScheme.ClosureAntitone | Mathlib.Topology.MetricSpace.CantorScheme | {β : Type u_1} → {α : Type u_2} → (List β → Set α) → [TopologicalSpace α] → Prop |
List.foldrM_filterMap | Init.Data.List.Monadic | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → Option β} {g : β → γ → m γ} {l : List α} {init : γ},
List.foldrM g init (List.filterMap f l) =
List.foldrM
(fun x y =>
match f x with
| some b => g b y
| none => pure y)
init l |
Std.HashMap.Raw.getKey!_emptyWithCapacity | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} [inst : BEq α] [inst_1 : Hashable α] [inst_2 : Inhabited α] {a : α} {c : ℕ},
(Std.HashMap.Raw.emptyWithCapacity c).getKey! a = default |
CategoryTheory.Functor.HomObj.comp_app | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {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} {A : CategoryTheory.Functor C (Type w)} {M : CategoryTheory.Functor C D}
(f : F.HomObj G A) (g : G.HomObj M A) (X : C) (a : A.obj X),
(f.comp g).app X a = CategoryTheory.CategoryStruct.comp (f.app X a) (g.app X a) |
Vector.exists_of_mem_flatMap | Init.Data.Vector.Lemmas | ∀ {β : Type u_1} {α : Type u_2} {n m : ℕ} {b : β} {xs : Vector α n} {f : α → Vector β m},
b ∈ xs.flatMap f → ∃ a ∈ xs, b ∈ f a |
NumberField.recOn | Mathlib.NumberTheory.NumberField.Basic | {K : Type u_1} →
[inst : Field K] →
{motive : NumberField K → Sort u} →
(t : NumberField K) →
([to_charZero : CharZero K] → [to_finiteDimensional : FiniteDimensional ℚ K] → motive ⋯) → motive t |
nhds_le_nhdsSet | Mathlib.Topology.NhdsSet | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X} {x : X}, x ∈ s → nhds x ≤ nhdsSet s |
Matroid.spanning_iff_compl_coindep | Mathlib.Combinatorics.Matroid.Closure | ∀ {α : Type u_2} {M : Matroid α} {S : Set α},
autoParam (S ⊆ M.E) Matroid.spanning_iff_compl_coindep._auto_1 → (M.Spanning S ↔ M.Coindep (M.E \ S)) |
Array.getElem_shrink._proof_2 | Init.Data.Array.Lemmas | ∀ {α : Type u_1} {xs : Array α} {i j : ℕ}, j < (xs.shrink i).size → j < xs.size |
NumberField.Units.dirichletUnitTheorem.mult_log_place_eq_zero | Mathlib.NumberTheory.NumberField.Units.DirichletTheorem | ∀ {K : Type u_1} [inst : Field K] {x : (NumberField.RingOfIntegers K)ˣ} {w : NumberField.InfinitePlace K},
↑w.mult * Real.log (w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x)) = 0 ↔
w ((algebraMap (NumberField.RingOfIntegers K) K) ↑x) = 1 |
Module.Presentation.tautological.R.recOn | Mathlib.Algebra.Module.Presentation.Tautological | {A : Type u} →
{M : Type v} →
{motive : Module.Presentation.tautological.R A M → Sort u_1} →
(t : Module.Presentation.tautological.R A M) →
((m₁ m₂ : M) → motive (Module.Presentation.tautological.R.add m₁ m₂)) →
((a : A) → (m : M) → motive (Module.Presentation.tautological.R.smul a m)) → motive t |
List.Perm.length_eq | Init.Data.List.Perm | ∀ {α : Type u_1} {l₁ l₂ : List α}, l₁.Perm l₂ → l₁.length = l₂.length |
CategoryTheory.Limits.ChosenPullback.p₂ | Mathlib.CategoryTheory.Limits.Shapes.Pullback.ChosenPullback | {C : Type u} →
[inst : CategoryTheory.Category.{v, u} C] →
{X₁ X₂ S : C} →
{f₁ : X₁ ⟶ S} → {f₂ : X₂ ⟶ S} → (self : CategoryTheory.Limits.ChosenPullback f₁ f₂) → self.pullback ⟶ X₂ |
_private.Init.Data.List.Attach.0.List.pmap_eq_pmapImpl.match_1_1 | Init.Data.List.Attach | (α : Type u_1) →
(p : α → Prop) →
(motive : Subtype p → Sort u_2) → (x : Subtype p) → ((x : α) → (hx : p x) → motive ⟨x, hx⟩) → motive x |
Std.Rxi.Iterator.toList_eq_match | Init.Data.Range.Polymorphic.Lemmas | ∀ {α : Type u} [inst : Std.PRange.UpwardEnumerable α] [Std.Rxi.IsAlwaysFinite α] [Std.PRange.LawfulUpwardEnumerable α]
{it : Std.Iter α},
it.toList =
match it.internalState.next with
| none => []
| some a => a :: { internalState := { next := Std.PRange.succ? a } }.toList |
measurable_of_countable | Mathlib.MeasureTheory.MeasurableSpace.Basic | ∀ {α : Type u_1} {β : Type u_2} [inst : MeasurableSpace α] [inst_1 : MeasurableSpace β] [Countable α]
[MeasurableSingletonClass α] (f : α → β), Measurable f |
_private.Init.Data.List.Impl.0.List.takeWhileTR.go | Init.Data.List.Impl | {α : Type u_1} → (α → Bool) → List α → List α → Array α → List α |
Polynomial.X_pow_sub_one_separable_iff | Mathlib.FieldTheory.Separable | ∀ {F : Type u} [inst : Field F] {n : ℕ}, (Polynomial.X ^ n - 1).Separable ↔ ↑n ≠ 0 |
Complex.ofReal_comp_pow | Mathlib.Data.Complex.Basic | ∀ {α : Type u_1} (f : α → ℝ) (n : ℕ), Complex.ofReal ∘ (f ^ n) = Complex.ofReal ∘ f ^ n |
Matroid.Nonempty.casesOn | Mathlib.Combinatorics.Matroid.Basic | {α : Type u_1} →
{M : Matroid α} →
{motive : M.Nonempty → Sort u} → (t : M.Nonempty) → ((ground_nonempty : M.E.Nonempty) → motive ⋯) → motive t |
List.forall_iff_forall_mem | Mathlib.Data.List.Basic | ∀ {α : Type u} {p : α → Prop} {l : List α}, List.Forall p l ↔ ∀ x ∈ l, p x |
_private.Mathlib.LinearAlgebra.Eigenspace.Basic.0.Module.End.eigenspace_restrict_le_eigenspace._simp_1_1 | Mathlib.LinearAlgebra.Eigenspace.Basic | ∀ {A : Type u_1} {B : Type u_2} [i : SetLike A B] {p : A} {x : B}, (x ∈ ↑p) = (x ∈ p) |
PreOpposite.op'.inj | Mathlib.Algebra.Opposites | ∀ {α : Type u_3} {unop' unop'_1 : α}, { unop' := unop' } = { unop' := unop'_1 } → unop' = unop'_1 |
LieSubmodule.gi._proof_2 | Mathlib.Algebra.Lie.Submodule | ∀ (R : Type u_2) (L : Type u_3) (M : Type u_1) [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : AddCommGroup M]
[inst_3 : Module R M] [inst_4 : LieRingModule L M] (x : Set M),
↑(LieSubmodule.lieSpan R L x) ≤ x → LieSubmodule.lieSpan R L x = LieSubmodule.lieSpan R L x |
Std.TreeSet.foldrM_eq_foldrM_toList | Std.Data.TreeSet.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.TreeSet α cmp} {δ : Type w} {m : Type w → Type w'} [inst : Monad m]
[LawfulMonad m] {f : α → δ → m δ} {init : δ}, Std.TreeSet.foldrM f init t = List.foldrM f init t.toList |
_private.Mathlib.CategoryTheory.Iso.0.CategoryTheory.Iso.cancel_iso_hom_right_assoc._simp_1_2 | Mathlib.CategoryTheory.Iso | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X Y Z : C} (f : Y ⟶ X) [CategoryTheory.Mono f] {g h : Z ⟶ Y},
(CategoryTheory.CategoryStruct.comp g f = CategoryTheory.CategoryStruct.comp h f) = (g = h) |
CategoryTheory.Abelian.Ext.homEquiv₀_symm_apply | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Abelian C]
[inst_2 : CategoryTheory.HasExt C] {X Y : C} (a : X ⟶ Y),
CategoryTheory.Abelian.Ext.homEquiv₀.symm a = CategoryTheory.Abelian.Ext.mk₀ a |
AddCommute.map | Mathlib.Algebra.Group.Commute.Hom | ∀ {F : Type u_1} {M : Type u_2} {N : Type u_3} [inst : Add M] [inst_1 : Add N] {x y : M} [inst_2 : FunLike F M N]
[AddHomClass F M N], AddCommute x y → ∀ (f : F), AddCommute (f x) (f y) |
PNat.toPNat'_coe | Mathlib.Data.PNat.Defs | ∀ {n : ℕ}, 0 < n → ↑n.toPNat' = n |
CategoryTheory.JointlyFaithful | Mathlib.CategoryTheory.Functor.ReflectsIso.Jointly | {C : Type u_1} →
[inst : CategoryTheory.Category.{u_4, u_1} C] →
{I : Type u_2} →
{D : I → Type u_3} →
[inst_1 : (i : I) → CategoryTheory.Category.{u_5, u_3} (D i)] →
((i : I) → CategoryTheory.Functor C (D i)) → Prop |
WeierstrassCurve.Jacobian.Point.toAffineLift_of_Z_eq_zero | Mathlib.AlgebraicGeometry.EllipticCurve.Jacobian.Point | ∀ {F : Type u} [inst : Field F] {W : WeierstrassCurve.Jacobian F} {P : Fin 3 → F} (hP : W.NonsingularLift ⟦P⟧),
P 2 = 0 → { point := ⟦P⟧, nonsingular := hP }.toAffineLift = 0 |
strictConvexOn_of_deriv2_pos | Mathlib.Analysis.Convex.Deriv | ∀ {D : Set ℝ},
Convex ℝ D → ∀ {f : ℝ → ℝ}, ContinuousOn f D → (∀ x ∈ interior D, 0 < deriv^[2] f x) → StrictConvexOn ℝ D f |
CategoryTheory.Monad.forgetCreatesColimits | Mathlib.CategoryTheory.Monad.Limits | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{T : CategoryTheory.Monad C} →
[CategoryTheory.Limits.PreservesColimitsOfSize.{v, u, v₁, v₁, u₁, u₁} T.toFunctor] →
CategoryTheory.CreatesColimitsOfSize.{v, u, v₁, v₁, max u₁ v₁, u₁} T.forget |
Ring.instIsDomainNormalClosure | Mathlib.RingTheory.NormalClosure | ∀ (R : Type u_1) (S : Type u_2) [inst : CommRing R] [inst_1 : CommRing S] [inst_2 : IsDomain R] [inst_3 : IsDomain S]
[inst_4 : Algebra R S] [inst_5 : Module.IsTorsionFree R S], IsDomain (Ring.NormalClosure R S) |
Rat.commRing._proof_11 | Mathlib.Algebra.Ring.Rat | ∀ (a : ℚ), SubNegMonoid.zsmul 0 a = 0 |
Lean.Level.PP.Result.maxNode.noConfusion | Lean.Level | {P : Sort u} →
{a a' : List Lean.Level.PP.Result} →
Lean.Level.PP.Result.maxNode a = Lean.Level.PP.Result.maxNode a' → (a = a' → P) → P |
HahnEmbedding.Seed.mk.sizeOf_spec | Mathlib.Algebra.Order.Module.HahnEmbedding | ∀ {K : Type u_1} [inst : DivisionRing K] [inst_1 : LinearOrder K] [inst_2 : IsOrderedRing K] [inst_3 : Archimedean K]
{M : Type u_2} [inst_4 : AddCommGroup M] [inst_5 : LinearOrder M] [inst_6 : IsOrderedAddMonoid M]
[inst_7 : Module K M] [inst_8 : IsOrderedModule K M] {R : Type u_3} [inst_9 : AddCommGroup R]
[inst_10 : LinearOrder R] [inst_11 : Module K R] [inst_12 : SizeOf K] [inst_13 : SizeOf M] [inst_14 : SizeOf R]
(toArchimedeanStrata : HahnEmbedding.ArchimedeanStrata K M)
(coeff : (c : FiniteArchimedeanClass M) → ↥(toArchimedeanStrata.stratum c) →ₗ[K] R)
(strictMono_coeff : ∀ (c : FiniteArchimedeanClass M), StrictMono ⇑(coeff c)),
sizeOf { toArchimedeanStrata := toArchimedeanStrata, coeff := coeff, strictMono_coeff := strictMono_coeff } =
1 + sizeOf toArchimedeanStrata |
Std.HashMap.Raw.distinct_keys | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] [EquivBEq α]
[LawfulHashable α], m.WF → List.Pairwise (fun a b => (a == b) = false) m.keys |
AlgebraicGeometry.Scheme.Modules.fromTildeΓ._proof_6 | Mathlib.AlgebraicGeometry.Modules.Tilde | ∀ {R : CommRingCat} (M : (AlgebraicGeometry.Spec (CommRingCat.of ↑R)).Modules) (f : (↑R)ᵒᵖ)
(x : ↥(Submonoid.powers (Opposite.unop f))),
IsUnit
((algebraMap (↑R)
(Module.End ↑R
↑((AlgebraicGeometry.modulesSpecToSheaf.obj M).obj.obj
(Opposite.op ((CategoryTheory.inducedFunctor PrimeSpectrum.basicOpen).obj (Opposite.unop f))))))
↑x) |
Lean.Lsp.TextDocumentSyncOptions.noConfusion | Lean.Data.Lsp.TextSync | {P : Sort u} →
{t t' : Lean.Lsp.TextDocumentSyncOptions} → t = t' → Lean.Lsp.TextDocumentSyncOptions.noConfusionType P t t' |
hasCardinalLT_iff_cardinal_mk_lt | Mathlib.SetTheory.Cardinal.HasCardinalLT | ∀ (X : Type u) (κ : Cardinal.{u}), HasCardinalLT X κ ↔ Cardinal.mk X < κ |
FreeLieAlgebra.Rel.smulOfTower | Mathlib.Algebra.Lie.Free | ∀ {R : Type u} {X : Type v} [inst : CommRing R] {S : Type u_1} [inst_1 : Monoid S] [inst_2 : DistribMulAction S R]
[IsScalarTower S R R] (t : S) (a b : FreeNonUnitalNonAssocAlgebra R X),
FreeLieAlgebra.Rel R X a b → FreeLieAlgebra.Rel R X (t • a) (t • b) |
Associates.factors_subsingleton | Mathlib.RingTheory.UniqueFactorizationDomain.FactorSet | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : UniqueFactorizationMonoid α] [Subsingleton α]
{a : Associates α}, a.factors = ⊤ |
ne_zero_of_map | Mathlib.Algebra.Group.Hom.Defs | ∀ {R : Type u_10} {S : Type u_11} {F : Type u_12} [inst : Zero R] [inst_1 : Zero S] [inst_2 : FunLike F R S]
[ZeroHomClass F R S] {f : F} {x : R}, f x ≠ 0 → x ≠ 0 |
_private.Init.Data.BitVec.Lemmas.0.BitVec.ne_intMin_of_msb_eq_false._proof_1_3 | Init.Data.BitVec.Lemmas | ∀ {w : ℕ}, 0 < w → w = 0 → False |
_private.Mathlib.RingTheory.NonUnitalSubsemiring.Basic.0.NonUnitalSubsemiring.coe_closure_eq._simp_1_1 | Mathlib.RingTheory.NonUnitalSubsemiring.Basic | ∀ {R : Type u} [inst : NonUnitalNonAssocSemiring R] (M : Subsemigroup R),
AddSubmonoid.closure ↑M = M.nonUnitalSubsemiringClosure.toAddSubmonoid |
Matrix.parabolicEigenvalue._proof_1 | Mathlib.LinearAlgebra.Matrix.GeneralLinearGroup.FinTwo | (1 + 1).AtLeastTwo |
_private.Mathlib.Analysis.Calculus.Taylor.0.taylor_mean_remainder_cauchy._simp_1_7 | Mathlib.Analysis.Calculus.Taylor | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False |
USize.ofNatLT | Init.Prelude | (n : ℕ) → n < USize.size → USize |
convexHull_eq_iInter | Mathlib.Analysis.Convex.Hull | ∀ (𝕜 : Type u_1) {E : Type u_2} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : Module 𝕜 E] (s : Set E), (convexHull 𝕜) s = ⋂ t, ⋂ (_ : s ⊆ t), ⋂ (_ : Convex 𝕜 t), t |
SSet.horn.primitiveTriangle._proof_3 | Mathlib.AlgebraicTopology.SimplicialSet.Horn | ∀ {n : ℕ}, ∀ k < n + 2, k < n + 3 + 1 |
Batteries.Random.MersenneTwister.State.mk.injEq | Batteries.Data.Random.MersenneTwister | ∀ {cfg : Batteries.Random.MersenneTwister.Config} (data : Vector (BitVec cfg.wordSize) cfg.stateSize)
(index : Fin cfg.stateSize) (data_1 : Vector (BitVec cfg.wordSize) cfg.stateSize) (index_1 : Fin cfg.stateSize),
({ data := data, index := index } = { data := data_1, index := index_1 }) = (data = data_1 ∧ index = index_1) |
CategoryTheory.ihom.ev_coev_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] (A B : C)
[inst_2 : CategoryTheory.Closed A] {Z : C} (h : CategoryTheory.MonoidalCategoryStruct.tensorObj A B ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCategoryStruct.whiskerLeft A ((CategoryTheory.ihom.coev A).app B))
(CategoryTheory.CategoryStruct.comp
((CategoryTheory.ihom.ev A).app (CategoryTheory.MonoidalCategoryStruct.tensorObj A B)) h) =
h |
_private.Mathlib.Data.Multiset.Bind.0.Multiset.nodup_bind._simp_1_1 | Mathlib.Data.Multiset.Bind | ∀ {α : Type u} {β : Type v} {l₁ : List α} {f : α → List β},
(List.flatMap f l₁).Nodup = ((∀ x ∈ l₁, (f x).Nodup) ∧ List.Pairwise (Function.onFun List.Disjoint f) l₁) |
MeasureTheory.IsStoppingTime.measurableSpace.congr_simp | Mathlib.Probability.Martingale.OptionalSampling | ∀ {Ω : Type u_1} {ι : Type u_3} {m : MeasurableSpace Ω} [inst : Preorder ι] {f f_1 : MeasureTheory.Filtration ι m}
(e_f : f = f_1) {τ τ_1 : Ω → WithTop ι} (e_τ : τ = τ_1) (hτ : MeasureTheory.IsStoppingTime f τ),
hτ.measurableSpace = ⋯.measurableSpace |
CategoryTheory.Functor.PushoutObjObj.mapArrowRight_comp | Mathlib.CategoryTheory.Limits.Shapes.Pullback.PullbackObjObj | ∀ {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₃)} {f₁ : CategoryTheory.Arrow C₁}
{f₂ f₂' : CategoryTheory.Arrow C₂} (sq₁₂ : F.PushoutObjObj f₁.hom f₂.hom) (sq₁₂' : F.PushoutObjObj f₁.hom f₂'.hom)
{f₂'' : CategoryTheory.Arrow C₂} (sq₁₂'' : F.PushoutObjObj f₁.hom f₂''.hom) (sq : f₂ ⟶ f₂') (sq' : f₂' ⟶ f₂''),
CategoryTheory.CategoryStruct.comp (sq₁₂.mapArrowRight sq₁₂' sq) (sq₁₂'.mapArrowRight sq₁₂'' sq') =
sq₁₂.mapArrowRight sq₁₂'' (CategoryTheory.CategoryStruct.comp sq sq') |
_private.Mathlib.GroupTheory.ClassEquation.0.Group.nat_card_center_add_sum_card_noncenter_eq_card._simp_1_6 | Mathlib.GroupTheory.ClassEquation | ∀ {α : Type u} {s : Set α}, (¬s.Nontrivial) = s.Subsingleton |
_private.Mathlib.Computability.TuringMachine.0.Turing.TM2.stepAux.match_1.eq_3 | Mathlib.Computability.TuringMachine | ∀ {K : Type u_1} {Γ : K → Type u_2} {Λ : Type u_3} {σ : Type u_4}
(motive : Turing.TM2.Stmt Γ Λ σ → σ → ((k : K) → List (Γ k)) → Sort u_5) (k : K) (f : σ → Option (Γ k) → σ)
(q : Turing.TM2.Stmt Γ Λ σ) (v : σ) (S : (k : K) → List (Γ k))
(h_1 :
(k : K) →
(f : σ → Γ k) →
(q : Turing.TM2.Stmt Γ Λ σ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.push k f q) v S)
(h_2 :
(k : K) →
(f : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.peek k f q) v S)
(h_3 :
(k : K) →
(f : σ → Option (Γ k) → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.pop k f q) v S)
(h_4 :
(a : σ → σ) →
(q : Turing.TM2.Stmt Γ Λ σ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.load a q) v S)
(h_5 :
(f : σ → Bool) →
(q₁ q₂ : Turing.TM2.Stmt Γ Λ σ) →
(v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.branch f q₁ q₂) v S)
(h_6 : (f : σ → Λ) → (v : σ) → (S : (k : K) → List (Γ k)) → motive (Turing.TM2.Stmt.goto f) v S)
(h_7 : (v : σ) → (S : (k : K) → List (Γ k)) → motive Turing.TM2.Stmt.halt v S),
(match Turing.TM2.Stmt.pop k f q, v, S with
| Turing.TM2.Stmt.push k f q, v, S => h_1 k f q v S
| Turing.TM2.Stmt.peek k f q, v, S => h_2 k f q v S
| Turing.TM2.Stmt.pop k f q, v, S => h_3 k f q v S
| Turing.TM2.Stmt.load a q, v, S => h_4 a q v S
| Turing.TM2.Stmt.branch f q₁ q₂, v, S => h_5 f q₁ q₂ v S
| Turing.TM2.Stmt.goto f, v, S => h_6 f v S
| Turing.TM2.Stmt.halt, v, S => h_7 v S) =
h_3 k f q v S |
cfc_le_one_iff | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Unital | ∀ {R : Type u_1} {A : Type u_2} {p : A → Prop} [inst : CommRing R] [inst_1 : PartialOrder R] [inst_2 : StarRing R]
[inst_3 : MetricSpace R] [inst_4 : IsTopologicalRing R] [inst_5 : ContinuousStar R] [ContinuousSqrt R]
[StarOrderedRing R] [inst_8 : TopologicalSpace A] [inst_9 : Ring A] [inst_10 : StarRing A] [inst_11 : PartialOrder A]
[StarOrderedRing A] [inst_13 : Algebra R A] [instCFC : ContinuousFunctionalCalculus R A p] [NonnegSpectrumClass R A]
(f : R → R) (a : A),
autoParam (ContinuousOn f (spectrum R a)) cfc_le_one_iff._auto_1 →
autoParam (p a) cfc_le_one_iff._auto_3 → (cfc f a ≤ 1 ↔ ∀ x ∈ spectrum R a, f x ≤ 1) |
Set.cast_ncard_sdiff | Mathlib.Data.Set.Card | ∀ {α : Type u_1} {s t : Set α} {R : Type u_3} [inst : AddGroupWithOne R],
s ⊆ t → t.Finite → ↑(t \ s).ncard = ↑t.ncard - ↑s.ncard |
Lean.Meta.Match.Pattern.applyFVarSubst._unsafe_rec | Lean.Meta.Match.Basic | Lean.Meta.FVarSubst → Lean.Meta.Match.Pattern → Lean.Meta.Match.Pattern |
Function.Injective.addAction.eq_1 | Mathlib.Algebra.Group.Action.Defs | ∀ {M : Type u_1} {α : Type u_5} {β : Type u_6} [inst : AddMonoid M] [inst_1 : AddAction M α] [inst_2 : VAdd M β]
(f : β → α) (hf : Function.Injective f) (smul : ∀ (c : M) (x : β), f (c +ᵥ x) = c +ᵥ f x),
Function.Injective.addAction f hf smul = { toVAdd := inst_2, add_vadd := ⋯, zero_vadd := ⋯ } |
Subring.toNonUnitalSubring | Mathlib.Algebra.Ring.Subring.Defs | {R : Type u} → [inst : Ring R] → Subring R → NonUnitalSubring R |
_private.Mathlib.Analysis.SpecialFunctions.BinaryEntropy.0.Real.deriv2_qaryEntropy._simp_1_3 | Mathlib.Analysis.SpecialFunctions.BinaryEntropy | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 4] [NeZero 4], (4 = 0) = False |
Sym.cast._proof_1 | Mathlib.Data.Sym.Basic | ∀ {α : Type u_1} {n m : ℕ} (h : n = m), Function.LeftInverse (fun s => ⟨↑s, ⋯⟩) fun s => ⟨↑s, ⋯⟩ |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.