name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
CategoryTheory.Limits.createsLimitsOfShapeOfCreatesEqualizersAndProducts._proof_2 | Mathlib.CategoryTheory.Limits.Constructions.LimitsOfProductsAndEqualizers | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] {J : Type u_1} [inst_1 : CategoryTheory.SmallCategory J]
{D : Type u_5} [inst_2 : CategoryTheory.Category.{u_4, u_5} D]
[CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) D]
(G : CategoryTheory.Functor C D)
[CategoryTheory.CreatesLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) G],
CategoryTheory.Limits.HasLimitsOfShape (CategoryTheory.Discrete ((p : J × J) × (p.1 ⟶ p.2))) C |
Submonoid.LocalizationMap.mulEquivOfLocalizations_left_inv_apply | Mathlib.GroupTheory.MonoidLocalization.Maps | ∀ {M : Type u_1} [inst : CommMonoid M] {S : Submonoid M} {N : Type u_2} [inst_1 : CommMonoid N] {P : Type u_3}
[inst_2 : CommMonoid P] (f : S.LocalizationMap N) {k : N ≃* P} (x : N),
(f.mulEquivOfLocalizations (f.ofMulEquivOfLocalizations k)) x = k x |
Module.FaithfullyFlat.tensorProduct_mk_injective | Mathlib.RingTheory.Flat.FaithfullyFlat.Algebra | ∀ {A : Type u_1} {B : Type u_2} [inst : CommRing A] [inst_1 : CommRing B] [inst_2 : Algebra A B]
[Module.FaithfullyFlat A B] (M : Type u_3) [inst_4 : AddCommGroup M] [inst_5 : Module A M],
Function.Injective ⇑((TensorProduct.mk A B M) 1) |
CategoryTheory.Limits.WalkingPair.right.sizeOf_spec | Mathlib.CategoryTheory.Limits.Shapes.BinaryProducts | sizeOf CategoryTheory.Limits.WalkingPair.right = 1 |
TopologicalSpace.isTopologicalBasis_empty._simp_1 | Mathlib.Topology.Bases | ∀ {α : Type u} [t : TopologicalSpace α], TopologicalSpace.IsTopologicalBasis ∅ = IsEmpty α |
_private.Mathlib.MeasureTheory.PiSystem.0.isPiSystem_piiUnionInter._simp_1_5 | Mathlib.MeasureTheory.PiSystem | ∀ {α : Type u} (x : α) (a b : Set α), (x ∈ a ∩ b) = (x ∈ a ∧ x ∈ b) |
IsometryEquiv.mulLeft._proof_1 | Mathlib.Topology.MetricSpace.IsometricSMul | ∀ {G : Type u_1} [inst : Group G] [inst_1 : PseudoEMetricSpace G] [IsIsometricSMul G G] (c b c_1 : G),
edist (c * b) (c * c_1) = edist b c_1 |
FirstOrder.Language.DirectLimit.unify_sigma_mk_self | Mathlib.ModelTheory.DirectLimit | ∀ {L : FirstOrder.Language} {ι : Type v} [inst : Preorder ι] {G : ι → Type w} [inst_1 : (i : ι) → L.Structure (G i)]
(f : (i j : ι) → i ≤ j → L.Embedding (G i) (G j)) [DirectedSystem G fun i j h => ⇑(f i j h)] {α : Type u_1} {i : ι}
{x : α → G i},
FirstOrder.Language.DirectLimit.unify f (fun a => FirstOrder.Language.Structure.Sigma.mk f i (x a)) i ⋯ = x |
OnePoint.isClosed_image_coe._simp_1 | Mathlib.Topology.Compactification.OnePoint.Basic | ∀ {X : Type u_1} [inst : TopologicalSpace X] {s : Set X}, IsClosed (OnePoint.some '' s) = (IsClosed s ∧ IsCompact s) |
Nat.lt_add_one_of_lt | Init.Data.Nat.Basic | ∀ {a b : ℕ}, a < b → a < b + 1 |
Finset.inv_subset_div_right | Mathlib.Algebra.Group.Pointwise.Finset.Basic | ∀ {α : Type u_2} [inst : DecidableEq α] [inst_1 : DivisionMonoid α] {s t : Finset α}, 1 ∈ s → t⁻¹ ⊆ s / t |
_private.Init.Data.List.Attach.0.List.attach_filterMap._simp_1_3 | Init.Data.List.Attach | ∀ {α : Sort u_1}, (∃ _a, False) = False |
Nat._aux_Mathlib_Data_Nat_Factorial_Basic___macroRules_Nat_term_!_1 | Mathlib.Data.Nat.Factorial.Basic | Lean.Macro |
AffineIsometry | Mathlib.Analysis.Normed.Affine.Isometry | (𝕜 : Type u_1) →
{V : Type u_2} →
{V₂ : Type u_5} →
(P : Type u_10) →
(P₂ : Type u_11) →
[inst : NormedField 𝕜] →
[inst_1 : SeminormedAddCommGroup V] →
[NormedSpace 𝕜 V] →
[inst_3 : PseudoMetricSpace P] →
[NormedAddTorsor V P] →
[inst_5 : SeminormedAddCommGroup V₂] →
[NormedSpace 𝕜 V₂] →
[inst : PseudoMetricSpace P₂] →
[NormedAddTorsor V₂ P₂] → Type (max (max (max u_10 u_11) u_2) u_5) |
Lean.Compiler.LCNF.UnreachableBranches.Value.merge._unsafe_rec | Lean.Compiler.LCNF.ElimDeadBranches | Lean.Environment →
Lean.Compiler.LCNF.UnreachableBranches.Value →
Lean.Compiler.LCNF.UnreachableBranches.Value → Lean.Compiler.LCNF.UnreachableBranches.Value |
_private.Lean.Elab.Match.0.Lean.Elab.Term.ToDepElimPattern.throwInvalidPattern | Lean.Elab.Match | {α : Type} → Lean.Expr → Lean.MetaM α |
Fin.foldl_zero | Init.Data.Fin.Fold | ∀ {α : Sort u_1} (f : α → Fin 0 → α) (x : α), Fin.foldl 0 f x = x |
Lean.Meta.zetaDeltaLocalDecl | Lean.Meta.Tactic.Unfold | Lean.MVarId → Lean.FVarId → Lean.FVarId → Lean.MetaM Lean.MVarId |
_private.Mathlib.Tactic.CategoryTheory.Elementwise.0.Mathlib.Tactic.Elementwise.elementwiseExpr.mkHomElementwise.match_9 | Mathlib.Tactic.CategoryTheory.Elementwise | (motive : Lean.Expr × Lean.Expr → Sort u_1) →
(__discr : Lean.Expr × Lean.Expr) → ((C instC : Lean.Expr) → motive (C, instC)) → motive __discr |
Semiquot.partialOrder | Mathlib.Data.Semiquot | {α : Type u_1} → PartialOrder (Semiquot α) |
ISize.minValue_div_neg_one | Init.Data.SInt.Lemmas | ISize.minValue / -1 = ISize.minValue |
Fin.finsetImage_natAdd_Ici | Mathlib.Order.Interval.Finset.Fin | ∀ {n : ℕ} (m : ℕ) (i : Fin n), Finset.image (Fin.natAdd m) (Finset.Ici i) = Finset.Ici (Fin.natAdd m i) |
Bundle.Trivialization.symm_apply_of_notMem | Mathlib.Topology.FiberBundle.Trivialization | ∀ {B : Type u_1} {F : Type u_2} {E : B → Type u_3} [inst : TopologicalSpace B] [inst_1 : TopologicalSpace F]
[inst_2 : TopologicalSpace (Bundle.TotalSpace F E)] [inst_3 : (x : B) → Zero (E x)]
(e : Bundle.Trivialization F Bundle.TotalSpace.proj) {b : B}, b ∉ e.baseSet → ∀ (y : F), e.symm b y = 0 |
Std.HashMap.Raw.mem_insertMany_of_mem | Std.Data.HashMap.RawLemmas | ∀ {α : Type u} {β : Type v} {m : Std.HashMap.Raw α β} [inst : BEq α] [inst_1 : Hashable α] {ρ : Type w}
[inst_2 : ForIn Id ρ (α × β)] [EquivBEq α] [LawfulHashable α], m.WF → ∀ {l : ρ} {k : α}, k ∈ m → k ∈ m.insertMany l |
BoundedContinuousFunction.instCommMonoid | Mathlib.Topology.ContinuousMap.Bounded.Basic | {α : Type u} →
{R : Type u_2} →
[inst : TopologicalSpace α] →
[inst_1 : PseudoMetricSpace R] →
[inst_2 : CommMonoid R] → [BoundedMul R] → [ContinuousMul R] → CommMonoid (BoundedContinuousFunction α R) |
_private.Mathlib.MeasureTheory.Function.SimpleFunc.0.MeasureTheory.SimpleFunc.eapproxDiff.match_1.splitter | Mathlib.MeasureTheory.Function.SimpleFunc | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
Finset.mulLECancellable_prod._simp_2 | Mathlib.Algebra.Order.BigOperators.Group.Finset | ∀ {ι : Type u_1} {α : Type u_2} [inst : CommMonoid α] [inst_1 : LE α] [MulLeftMono α] {s : Finset ι} {f : ι → α},
MulLECancellable (∏ i ∈ s, f i) = ∀ ⦃i : ι⦄, i ∈ s → MulLECancellable (f i) |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_170 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w : α),
List.idxOfNth w [g (g a)] 1 + 1 ≤ (List.filter (fun x => decide (x = w)) [g (g a)]).length →
List.idxOfNth w [g (g a)] 1 < (List.findIdxs (fun x => decide (x = w)) [g (g a)]).length |
_private.Init.Data.String.Pattern.String.0.String.Slice.Pattern.ForwardSliceSearcher.buildTable.computeDistance._unary | Init.Data.String.Pattern.String | (pat : String.Slice) →
UInt8 →
(table : Array ℕ) →
table.size ≤ pat.utf8ByteSize →
(∀ (i : ℕ) (hi : i < table.size), table[i] ≤ i) → (guess : ℕ) ×' guess < table.size → { n // n ≤ table.size } |
Lean.Doc.MarkdownBlock.toMarkdown | Lean.DocString.Markdown | {i : Type u} →
{b : Type v} →
[self : Lean.Doc.MarkdownBlock i b] →
(Lean.Doc.Inline i → Lean.Doc.MarkdownM Unit) →
(Lean.Doc.Block i b → Lean.Doc.MarkdownM Unit) → b → Array (Lean.Doc.Block i b) → Lean.Doc.MarkdownM Unit |
Std.HashSet.Raw.erase_emptyWithCapacity | Std.Data.HashSet.RawLemmas | ∀ {α : Type u} [inst : BEq α] [inst_1 : Hashable α] {k : α} {c : ℕ},
(Std.HashSet.Raw.emptyWithCapacity c).erase k = Std.HashSet.Raw.emptyWithCapacity c |
LeftPreLieRing.casesOn | Mathlib.Algebra.NonAssoc.PreLie.Basic | {L : Type u_1} →
{motive : LeftPreLieRing L → Sort u} →
(t : LeftPreLieRing L) →
([toNonUnitalNonAssocRing : NonUnitalNonAssocRing L] →
(assoc_symm' : ∀ (x y z : L), associator x y z = associator y x z) →
motive { toNonUnitalNonAssocRing := toNonUnitalNonAssocRing, assoc_symm' := assoc_symm' }) →
motive t |
Lean.Lsp.instToJsonSemanticTokensParams | Lean.Data.Lsp.LanguageFeatures | Lean.ToJson Lean.Lsp.SemanticTokensParams |
_private.Mathlib.LinearAlgebra.Projection.0.LinearMap.IsIdempotentElem.comp_eq_right_iff._simp_1_5 | Mathlib.LinearAlgebra.Projection | ∀ {α : Sort u_2} {β : Sort u_1} {f : α → β} {p : β → Prop}, (∀ (b : β) (a : α), f a = b → p b) = ∀ (a : α), p (f a) |
Mathlib.Tactic.Translate.Reorder.below_3 | Mathlib.Tactic.Translate.Reorder | {motive_1 : Mathlib.Tactic.Translate.Reorder → Sort u} →
{motive_2 : Array (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_3 : List (ℕ × Mathlib.Tactic.Translate.Reorder) → Sort u} →
{motive_4 : ℕ × Mathlib.Tactic.Translate.Reorder → Sort u} → ℕ × Mathlib.Tactic.Translate.Reorder → Sort (max 1 u) |
Lean.Compiler.LCNF.MonadScope.mk | Lean.Compiler.LCNF.MonadScope | {m : Type → Type} →
m Lean.Compiler.LCNF.Scope →
({α : Type} → (Lean.Compiler.LCNF.Scope → Lean.Compiler.LCNF.Scope) → m α → m α) → Lean.Compiler.LCNF.MonadScope m |
Mathlib.Tactic.Push.instBEqHead.beq | Mathlib.Tactic.Push.Attr | Mathlib.Tactic.Push.Head → Mathlib.Tactic.Push.Head → Bool |
CategoryTheory.SimplicialObject.cechNerveEquiv._proof_2 | Mathlib.AlgebraicTopology.CechNerve | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C]
[inst_1 :
∀ (n : ℕ) (f : CategoryTheory.Arrow C),
CategoryTheory.Limits.HasWidePullback f.right (fun x => f.left) fun x => f.hom]
(X : CategoryTheory.SimplicialObject.Augmented C) (F : CategoryTheory.Arrow C),
Function.RightInverse (CategoryTheory.SimplicialObject.equivalenceRightToLeft X F)
(CategoryTheory.SimplicialObject.equivalenceLeftToRight X F) |
_private.Lean.Elab.PreDefinition.WF.GuessLex.0.Lean.Elab.WF.GuessLex.withRecApps.loop._unsafe_rec | Lean.Elab.PreDefinition.WF.GuessLex | {α : Type} →
(recFnName : Lean.Name) →
ℕ → (Lean.Expr → Array Lean.Expr → Lean.MetaM α) → Lean.Expr → Lean.Expr → Lean.Elab.WF.GuessLex.M recFnName α Unit |
Real.sSup_smul_of_nonneg | Mathlib.Data.Real.Pointwise | ∀ {α : Type u_2} [inst : Field α] [inst_1 : LinearOrder α] [IsStrictOrderedRing α] [inst_3 : MulActionWithZero α ℝ]
[IsOrderedModule α ℝ] {a : α}, 0 ≤ a → ∀ (s : Set ℝ), sSup (a • s) = a • sSup s |
cfcₙ_complex_eq_real._auto_1 | Mathlib.Analysis.CStarAlgebra.ContinuousFunctionalCalculus.Instances | Lean.Syntax |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent.0.Complex.cot_eq_exp_ratio._simp_1_2 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Cotangent | ∀ {α : Type u_2} [inst : Zero α] [inst_1 : OfNat α 3] [NeZero 3], (3 = 0) = False |
Lean.Meta.Rewrites.SideConditions.ctorElim | Lean.Meta.Tactic.Rewrites | {motive : Lean.Meta.Rewrites.SideConditions → Sort u} →
(ctorIdx : ℕ) →
(t : Lean.Meta.Rewrites.SideConditions) →
ctorIdx = t.ctorIdx → Lean.Meta.Rewrites.SideConditions.ctorElimType ctorIdx → motive t |
ConvexOn.convex_le | Mathlib.Analysis.Convex.Function | ∀ {𝕜 : Type u_1} {E : Type u_2} {β : Type u_5} [inst : Semiring 𝕜] [inst_1 : PartialOrder 𝕜] [inst_2 : AddCommMonoid E]
[inst_3 : AddCommMonoid β] [inst_4 : PartialOrder β] [IsOrderedAddMonoid β] [inst_6 : SMul 𝕜 E] [inst_7 : Module 𝕜 β]
[PosSMulMono 𝕜 β] {s : Set E} {f : E → β}, ConvexOn 𝕜 s f → ∀ (r : β), Convex 𝕜 {x | x ∈ s ∧ f x ≤ r} |
Vector.foldr_add_const | Init.Data.Vector.Lemmas | ∀ {α : Type u_1} {n : ℕ} {xs : Vector α n} {a b : ℕ}, Vector.foldr (fun x x_1 => x_1 + a) b xs = b + a * n |
sSupHom.symm_dual_comp | Mathlib.Order.Hom.CompleteLattice | ∀ {α : Type u_2} {β : Type u_3} {γ : Type u_4} [inst : SupSet α] [inst_1 : SupSet β] [inst_2 : SupSet γ]
(g : sInfHom βᵒᵈ γᵒᵈ) (f : sInfHom αᵒᵈ βᵒᵈ),
sSupHom.dual.symm (g.comp f) = (sSupHom.dual.symm g).comp (sSupHom.dual.symm f) |
AddLocalization.r_eq_r' | Mathlib.GroupTheory.MonoidLocalization.Basic | ∀ {M : Type u_1} [inst : AddCommMonoid M] (S : AddSubmonoid M), AddLocalization.r S = AddLocalization.r' S |
Nat.instNeZeroSucc | Init.Data.Nat.Basic | ∀ {n : ℕ}, NeZero (n + 1) |
Lean.Meta.Grind.Arith.Cutsat.resolveConflict | Lean.Meta.Tactic.Grind.Arith.Cutsat.Search | Lean.Meta.Grind.Arith.Cutsat.UnsatProof → Lean.Meta.Grind.Arith.Cutsat.SearchM Unit |
ProbabilityTheory.exponentialPDF | Mathlib.Probability.Distributions.Exponential | ℝ → ℝ → ENNReal |
Nat.primeFactors_pow | Mathlib.Data.Nat.PrimeFin | ∀ {k : ℕ} (n : ℕ), k ≠ 0 → (n ^ k).primeFactors = n.primeFactors |
Fin2.noConfusionType | Mathlib.Data.Fin.Fin2 | Sort u → {a : ℕ} → Fin2 a → {a' : ℕ} → Fin2 a' → Sort u |
Lean.Meta.Origin.decl.noConfusion | Lean.Meta.Tactic.Simp.SimpTheorems | {P : Sort u} →
{declName : Lean.Name} →
{post : optParam Bool true} →
{inv : optParam Bool false} →
{declName' : Lean.Name} →
{post' : optParam Bool true} →
{inv' : optParam Bool false} →
Lean.Meta.Origin.decl declName post inv = Lean.Meta.Origin.decl declName' post' inv' →
(declName = declName' → post = post' → inv = inv' → P) → P |
MultilinearMap.addCommMonoid._proof_7 | Mathlib.LinearAlgebra.Multilinear.Basic | ∀ {R : Type u_1} {ι : Type u_2} {M₁ : ι → Type u_3} {M₂ : Type u_4} [inst : Semiring R]
[inst_1 : (i : ι) → AddCommMonoid (M₁ i)] [inst_2 : AddCommMonoid M₂] [inst_3 : (i : ι) → Module R (M₁ i)]
[inst_4 : Module R M₂] (x : MultilinearMap R M₁ M₂), 0 • x = 0 |
Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastUdivOutput.mk | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Udiv | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] →
{old : Std.Sat.AIG α} →
{w : ℕ} →
(aig : Std.Sat.AIG α) →
aig.RefVec w →
aig.RefVec w →
old.decls.size ≤ aig.decls.size → Std.Tactic.BVDecide.BVExpr.bitblast.blastUdiv.BlastUdivOutput old w |
_private.Mathlib.NumberTheory.NumberField.House.0.NumberField.house.supOfBasis | Mathlib.NumberTheory.NumberField.House | (K : Type u_1) → [inst : Field K] → [NumberField K] → ℝ |
String.Slice.trimAscii | Init.Data.String.Slice | String.Slice → String.Slice |
PSet.Lift.match_1 | Mathlib.SetTheory.ZFC.PSet | (α : Type u_2) →
(motive : ULift.{u_1, u_2} α → Sort u_3) → (x : ULift.{u_1, u_2} α) → ((x : α) → motive { down := x }) → motive x |
lowerSemicontinuousWithinAt_sum | Mathlib.Topology.Semicontinuity.Basic | ∀ {α : Type u_1} [inst : TopologicalSpace α] {s : Set α} {x : α} {ι : Type u_4} {γ : Type u_5}
[inst_1 : AddCommMonoid γ] [inst_2 : LinearOrder γ] [IsOrderedAddMonoid γ] [inst_4 : TopologicalSpace γ]
[OrderTopology γ] [ContinuousAdd γ] {f : ι → α → γ} {a : Finset ι},
(∀ i ∈ a, LowerSemicontinuousWithinAt (f i) s x) → LowerSemicontinuousWithinAt (fun z => ∑ i ∈ a, f i z) s x |
Lean.Syntax.instReprPreresolved | Init.Meta.Defs | Repr Lean.Syntax.Preresolved |
ModularGroup.coe_S | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ↑ModularGroup.S = !![0, -1; 1, 0] |
_private.Mathlib.MeasureTheory.Covering.Besicovitch.0.Mathlib.Meta.Positivity.evalBesicovitchSatelliteConfigR._proof_1 | Mathlib.MeasureTheory.Covering.Besicovitch | ∀ (α : Q(Type)) (_zα : Q(Zero «$α»)) (__defeqres : PLift («$_zα» =Q Real.instZero)), «$_zα» =Q Real.instZero |
CategoryTheory.Functor.natTransEquiv._proof_5 | Mathlib.CategoryTheory.Functor.FunctorHom | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} C] {D : Type u_4}
[inst_1 : CategoryTheory.Category.{u_3, u_4} D] {F G : CategoryTheory.Functor C D}
(f :
CategoryTheory.MonoidalCategoryStruct.tensorUnit (CategoryTheory.Functor C (Type (max u_3 u_2 u_1))) ⟶
F.functorHom G),
(fun f => { app := fun x x_1 => CategoryTheory.Functor.HomObj.ofNatTrans f, naturality := ⋯ })
((fun f =>
{
app := fun X =>
(f.app X PUnit.unit).app X (CategoryTheory.CategoryStruct.id (Opposite.unop (Opposite.op X))),
naturality := ⋯ })
f) =
f |
Unitary.coe_neg._simp_1 | Mathlib.Algebra.Star.Unitary | ∀ {R : Type u_1} [inst : Ring R] [inst_1 : StarRing R] (U : ↥(unitary R)), -↑U = ↑(-U) |
IsDiscreteValuationRing.remainder.eq_1 | Mathlib.RingTheory.DiscreteValuationRing.Basic | ∀ {R : Type u_2} [inst : CommRing R] (x y : R), IsDiscreteValuationRing.remainder x y = if y ∣ x then 0 else x |
_private.Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic.0.CategoryTheory.Abelian.Ext.comp_assoc._proof_1_1 | Mathlib.Algebra.Homology.DerivedCategory.Ext.Basic | ∀ {a₁ a₂ a₃ a : ℕ}, a₁ + a₂ + a₃ = a → ↑a₃ + ↑a₂ + ↑a₁ = ↑a |
_private.Mathlib.Topology.UniformSpace.UniformApproximation.0.uniformContinuous_of_uniform_approx_of_uniformContinuous._simp_1_1 | Mathlib.Topology.UniformSpace.UniformApproximation | ∀ {α : Type ua} {β : Type ub} [inst : UniformSpace α] [inst_1 : UniformSpace β] {f : α → β},
UniformContinuousOn f Set.univ = UniformContinuous f |
Std.IterM.step_uLift.match_1 | Init.Data.Iterators.Lemmas.Combinators.Monadic.ULift | {α : Type u_1} →
{m : Type u_1 → Type u_2} →
{β : Type u_1} →
[inst : Std.Iterator α m β] →
{it : Std.IterM m β} →
(motive : it.Step → Sort u_3) →
(x : it.Step) →
((it' : Std.IterM m β) →
(out : β) →
(h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' out, h⟩) →
((it' : Std.IterM m β) →
(h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩) →
((h : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩) → motive x |
Matroid.contract_finitary | Mathlib.Combinatorics.Matroid.Minor.Contract | ∀ {α : Type u_1} {M : Matroid α} {C : Set α} [M.Finitary], (M.contract C).Finitary |
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.mk.noConfusion | Mathlib.CategoryTheory.Limits.Shapes.Pullback.Categorical.Basic | {A : Type u₁} →
{B : Type u₂} →
{C : Type u₃} →
{inst : CategoryTheory.Category.{v₁, u₁} A} →
{inst_1 : CategoryTheory.Category.{v₂, u₂} B} →
{inst_2 : CategoryTheory.Category.{v₃, u₃} C} →
{F : CategoryTheory.Functor A B} →
{G : CategoryTheory.Functor C B} →
{X : Type u₄} →
{inst_3 : CategoryTheory.Category.{v₄, u₄} X} →
{x y : CategoryTheory.Limits.CategoricalPullback.CatCommSqOver F G X} →
{P : Sort u} →
{fst : x.fst ⟶ y.fst} →
{snd : x.snd ⟶ y.snd} →
{w :
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight fst F)
y.iso.hom =
CategoryTheory.CategoryStruct.comp x.iso.hom
(CategoryTheory.Functor.whiskerRight snd G))
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.w._autoParam} →
{fst' : x.fst ⟶ y.fst} →
{snd' : x.snd ⟶ y.snd} →
{w' :
autoParam
(CategoryTheory.CategoryStruct.comp (CategoryTheory.Functor.whiskerRight fst' F)
y.iso.hom =
CategoryTheory.CategoryStruct.comp x.iso.hom
(CategoryTheory.Functor.whiskerRight snd' G))
CategoryTheory.Limits.CategoricalPullback.CatCommSqOver.Hom.w._autoParam} →
{ fst := fst, snd := snd, w := w } = { fst := fst', snd := snd', w := w' } →
(fst ≍ fst' → snd ≍ snd' → P) → P |
CategoryTheory.Limits.snd_opProdIsoCoprod_hom | Mathlib.CategoryTheory.Limits.Shapes.Opposites.Products | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {A B : C}
[inst_1 : CategoryTheory.Limits.HasBinaryProduct A B],
CategoryTheory.CategoryStruct.comp CategoryTheory.Limits.prod.snd.op (CategoryTheory.Limits.opProdIsoCoprod A B).hom =
CategoryTheory.Limits.coprod.inr |
Lean.PrettyPrinter.Formatter.State.isUngrouped._default | Lean.PrettyPrinter.Formatter | Bool |
_private.Mathlib.ModelTheory.Syntax.0.FirstOrder.Language.Term.constantsVarsEquiv._simp_2 | Mathlib.ModelTheory.Syntax | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True |
Polynomial.monomial_sub | Mathlib.Algebra.Polynomial.Basic | ∀ {R : Type u} {a b : R} [inst : Ring R] (n : ℕ),
(Polynomial.monomial n) (a - b) = (Polynomial.monomial n) a - (Polynomial.monomial n) b |
SimpleGraph.Walk.IsPath.ne_of_mem_support_of_append | Mathlib.Combinatorics.SimpleGraph.Paths | ∀ {V : Type u} {G : SimpleGraph V} {u v w : V} {p : G.Walk u v} {q : G.Walk v w},
(p.append q).IsPath → ∀ {x y : V}, y ≠ v → x ∈ p.support → y ∈ q.support → x ≠ y |
Lean.Meta.Simp.Config.mk.noConfusion | Init.MetaTypes | {P : Sort u} →
{maxSteps maxDischargeDepth : ℕ} →
{contextual memoize singlePass zeta beta eta : Bool} →
{etaStruct : Lean.Meta.EtaStructMode} →
{iota proj decide arith autoUnfold dsimp failIfUnchanged ground unfoldPartialApp zetaDelta index
implicitDefEqProofs zetaUnused catchRuntime zetaHave letToHave congrConsts bitVecOfNat warnExponents
suggestions : Bool} →
{maxSuggestions : Option ℕ} →
{locals instances : Bool} →
{maxSteps' maxDischargeDepth' : ℕ} →
{contextual' memoize' singlePass' zeta' beta' eta' : Bool} →
{etaStruct' : Lean.Meta.EtaStructMode} →
{iota' proj' decide' arith' autoUnfold' dsimp' failIfUnchanged' ground' unfoldPartialApp' zetaDelta'
index' implicitDefEqProofs' zetaUnused' catchRuntime' zetaHave' letToHave' congrConsts'
bitVecOfNat' warnExponents' suggestions' : Bool} →
{maxSuggestions' : Option ℕ} →
{locals' instances' : Bool} →
{ maxSteps := maxSteps, maxDischargeDepth := maxDischargeDepth, contextual := contextual,
memoize := memoize, singlePass := singlePass, zeta := zeta, beta := beta, eta := eta,
etaStruct := etaStruct, iota := iota, proj := proj, decide := decide, arith := arith,
autoUnfold := autoUnfold, dsimp := dsimp, failIfUnchanged := failIfUnchanged,
ground := ground, unfoldPartialApp := unfoldPartialApp, zetaDelta := zetaDelta,
index := index, implicitDefEqProofs := implicitDefEqProofs, zetaUnused := zetaUnused,
catchRuntime := catchRuntime, zetaHave := zetaHave, letToHave := letToHave,
congrConsts := congrConsts, bitVecOfNat := bitVecOfNat, warnExponents := warnExponents,
suggestions := suggestions, maxSuggestions := maxSuggestions, locals := locals,
instances := instances } =
{ maxSteps := maxSteps', maxDischargeDepth := maxDischargeDepth',
contextual := contextual', memoize := memoize', singlePass := singlePass',
zeta := zeta', beta := beta', eta := eta', etaStruct := etaStruct', iota := iota',
proj := proj', decide := decide', arith := arith', autoUnfold := autoUnfold',
dsimp := dsimp', failIfUnchanged := failIfUnchanged', ground := ground',
unfoldPartialApp := unfoldPartialApp', zetaDelta := zetaDelta', index := index',
implicitDefEqProofs := implicitDefEqProofs', zetaUnused := zetaUnused',
catchRuntime := catchRuntime', zetaHave := zetaHave', letToHave := letToHave',
congrConsts := congrConsts', bitVecOfNat := bitVecOfNat',
warnExponents := warnExponents', suggestions := suggestions',
maxSuggestions := maxSuggestions', locals := locals', instances := instances' } →
(maxSteps = maxSteps' →
maxDischargeDepth = maxDischargeDepth' →
contextual = contextual' →
memoize = memoize' →
singlePass = singlePass' →
zeta = zeta' →
beta = beta' →
eta = eta' →
etaStruct = etaStruct' →
iota = iota' →
proj = proj' →
decide = decide' →
arith = arith' →
autoUnfold = autoUnfold' →
dsimp = dsimp' →
failIfUnchanged = failIfUnchanged' →
ground = ground' →
unfoldPartialApp = unfoldPartialApp' →
zetaDelta = zetaDelta' →
index = index' →
implicitDefEqProofs = implicitDefEqProofs' →
zetaUnused = zetaUnused' →
catchRuntime = catchRuntime' →
zetaHave = zetaHave' →
letToHave = letToHave' →
congrConsts = congrConsts' →
bitVecOfNat = bitVecOfNat' →
warnExponents = warnExponents' →
suggestions = suggestions' →
maxSuggestions =
maxSuggestions' →
locals = locals' →
instances = instances' →
P) →
P |
preNormEDS'_odd | Mathlib.NumberTheory.EllipticDivisibilitySequence | ∀ {R : Type u} [inst : CommRing R] (b c d : R) (m : ℕ),
preNormEDS' b c d (2 * (m + 2) + 1) =
(preNormEDS' b c d (m + 4) * preNormEDS' b c d (m + 2) ^ 3 * if Even m then b else 1) -
preNormEDS' b c d (m + 1) * preNormEDS' b c d (m + 3) ^ 3 * if Even m then 1 else b |
SimpleGraph.bot_not_preconnected | Mathlib.Combinatorics.SimpleGraph.Connectivity.Connected | ∀ {V : Type u} [Nontrivial V], ¬⊥.Preconnected |
Subring.range_fst | Mathlib.Algebra.Ring.Subring.Basic | ∀ {R : Type u} {S : Type v} [inst : Ring R] [inst_1 : Ring S], (RingHom.fst R S).rangeS = ⊤ |
CategoryTheory.Functor.Initial.limitConeOfComp | Mathlib.CategoryTheory.Limits.Final | {C : Type u₁} →
[inst : CategoryTheory.Category.{v₁, u₁} C] →
{D : Type u₂} →
[inst_1 : CategoryTheory.Category.{v₂, u₂} D] →
(F : CategoryTheory.Functor C D) →
[F.Initial] →
{E : Type u₃} →
[inst_3 : CategoryTheory.Category.{v₃, u₃} E] →
{G : CategoryTheory.Functor D E} →
CategoryTheory.Limits.LimitCone (F.comp G) → CategoryTheory.Limits.LimitCone G |
RingEquiv.sumArrowEquivProdArrow._proof_1 | Mathlib.Algebra.Ring.Equiv | ∀ (α : Type u_1) (β : Type u_2) (R : Type u_3) [inst : NonAssocSemiring R] (x x_1 : α ⊕ β → R),
(Equiv.sumArrowEquivProdArrow α β R).toFun (x * x_1) = (Equiv.sumArrowEquivProdArrow α β R).toFun (x * x_1) |
RingCat.instCreatesLimitSemiRingCatForget₂RingHomCarrierCarrier._proof_2 | Mathlib.Algebra.Category.Ring.Limits | ∀ {J : Type u_2} [inst : CategoryTheory.Category.{u_3, u_2} J] (F : CategoryTheory.Functor J RingCat)
[Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget RingCat)).sections],
Small.{u_1, max u_1 u_2} ↑(F.comp (CategoryTheory.forget RingCat)).sections |
IsNilpotent.exp_mul_exp_neg_self | Mathlib.RingTheory.Nilpotent.Exp | ∀ {A : Type u_1} [inst : Ring A] [inst_1 : Module ℚ A] {a : A},
IsNilpotent a → IsNilpotent.exp a * IsNilpotent.exp (-a) = 1 |
_private.Init.Data.Vector.Range.0.Vector.range'_eq_append_iff._simp_1_1 | Init.Data.Vector.Range | ∀ {α : Type u_1} {n : ℕ} {xs ys : Vector α n}, (xs = ys) = (xs.toArray = ys.toArray) |
MeasureTheory.Integrable.of_fst_of_snd_prodLp | Mathlib.MeasureTheory.SpecificCodomains.WithLp | ∀ {X : Type u_1} {mX : MeasurableSpace X} {μ : MeasureTheory.Measure X} {q : ENNReal} [inst : Fact (1 ≤ q)]
{E : Type u_2} {F : Type u_3} [inst_1 : NormedAddCommGroup E] [inst_2 : NormedAddCommGroup F]
{f : X → WithLp q (E × F)},
MeasureTheory.Integrable (fun x => (f x).fst) μ ∧ MeasureTheory.Integrable (fun x => (f x).snd) μ →
MeasureTheory.Integrable f μ |
CategoryTheory.Limits.FormalCoproduct.recOn | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | {C : Type u} →
{motive : CategoryTheory.Limits.FormalCoproduct C → Sort u_1} →
(t : CategoryTheory.Limits.FormalCoproduct C) →
((I : Type w) → (obj : I → C) → motive { I := I, obj := obj }) → motive t |
Prod.continuousAdd | Mathlib.Topology.Algebra.Monoid | ∀ {M : Type u_3} {N : Type u_4} [inst : TopologicalSpace M] [inst_1 : Add M] [ContinuousAdd M]
[inst_3 : TopologicalSpace N] [inst_4 : Add N] [ContinuousAdd N], ContinuousAdd (M × N) |
Array.range'_one | Init.Data.Array.Range | ∀ {s step : ℕ}, Array.range' s 1 step = #[s] |
Module.Basis.equivFun_apply | Mathlib.LinearAlgebra.Basis.Defs | ∀ {ι : Type u_1} {R : Type u_3} {M : Type u_6} [inst : Semiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : Finite ι] (b : Module.Basis ι R M) (u : M), b.equivFun u = ⇑(b.repr u) |
_private.Init.Data.List.ToArray.0.List.zipWith_toArray._simp_1_2 | Init.Data.List.ToArray | ∀ {m : Type u_1 → Type u_2} {α : Type u_3} {β : Type u_4} {γ : Type u_1} [inst : Monad m] [LawfulMonad m]
{f : α → β → m γ} {l : List α} {l' : List β}, List.zipWithM f l l' = List.zipWithM' f l l' |
ContinuousMulEquiv.toHomeomorph_eq_coe | Mathlib.Topology.Algebra.ContinuousMonoidHom | ∀ {M : Type u_1} {N : Type u_2} [inst : TopologicalSpace M] [inst_1 : TopologicalSpace N] [inst_2 : Mul M]
[inst_3 : Mul N] (f : M ≃ₜ* N), f.toHomeomorph = ↑f |
Finset.univ_disjSum_univ | Mathlib.Data.Fintype.Sum | ∀ {α : Type u_3} {β : Type u_4} [inst : Fintype α] [inst_1 : Fintype β], Finset.univ.disjSum Finset.univ = Finset.univ |
QuadraticAlgebra.norm_zero | Mathlib.Algebra.QuadraticAlgebra.Basic | ∀ {R : Type u_1} {a b : R} [inst : CommRing R], QuadraticAlgebra.norm 0 = 0 |
_private.Mathlib.SetTheory.Cardinal.UnivLE.0.univLE_iff_cardinal_le._simp_1_1 | Mathlib.SetTheory.Cardinal.UnivLE | UnivLE.{u, v} = ∀ (α : Type u), Small.{v, u} α |
ContinuousOn.add_const | Mathlib.Topology.Algebra.Monoid.Defs | ∀ {M : Type u_1} [inst : TopologicalSpace M] [inst_1 : Add M] [SeparatelyContinuousAdd M] {X : Type u_2}
[inst_3 : TopologicalSpace X] {f : X → M} {s : Set X}, ContinuousOn f s → ∀ (b : M), ContinuousOn (fun x => f x + b) s |
atTop_isCountablyGenerated_of_archimedean | Mathlib.Order.Filter.AtTopBot.Archimedean | ∀ {R : Type u_2} [inst : Semiring R] [inst_1 : PartialOrder R] [IsOrderedRing R] [Archimedean R],
Filter.atTop.IsCountablyGenerated |
Std.HashMap.not_mem_emptyWithCapacity | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {a : α} {c : ℕ}, a ∉ Std.HashMap.emptyWithCapacity c |
_private.Mathlib.GroupTheory.Perm.Cycle.Type.0.Equiv.Perm.IsThreeCycle.nodup_iff_mem_support._proof_1_220 | Mathlib.GroupTheory.Perm.Cycle.Type | ∀ {α : Type u_1} [inst_1 : DecidableEq α] {g : Equiv.Perm α} {a : α} (w_1 : α),
List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card + 1 ≤
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length →
List.idxOfNth w_1 [g a, g (g a)] {g a, g (g a)}.card <
(List.filter (fun x => decide (x = w_1)) [g a, g (g a)]).length |
CategoryTheory.Comma.rightIso_inv | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] {L₁ : CategoryTheory.Functor A T}
{R₁ : CategoryTheory.Functor B T} {X Y : CategoryTheory.Comma L₁ R₁} (α : X ≅ Y),
(CategoryTheory.Comma.rightIso α).inv = α.inv.right |
Real.sqrtTwoAddSeries.match_1 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Basic | (motive : ℕ → Sort u_1) → (x : ℕ) → (Unit → motive 0) → ((n : ℕ) → motive n.succ) → motive x |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.