name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.67M | allowCompletion bool 2
classes |
|---|---|---|---|
CategoryTheory.Bicategory.InducedBicategory.bicategory._proof_6 | Mathlib.CategoryTheory.Bicategory.InducedBicategory | ∀ {B : Type u_1} {C : Type u_2} [inst : CategoryTheory.Bicategory C] {F : B → C}
{a b : CategoryTheory.Bicategory.InducedBicategory C F} {f g : a ⟶ b} (η : f ⟶ g),
CategoryTheory.Bicategory.InducedBicategory.mkHom₂
(CategoryTheory.Bicategory.whiskerLeft (CategoryTheory.CategoryStruct.id a).hom η.hom) =
Ca... | false |
ContDiffPointwiseHolderAt.mk._flat_ctor | Mathlib.Analysis.Calculus.ContDiffHolder.Pointwise | ∀ {E : Type u_1} {F : Type u_2} [inst : NormedAddCommGroup E] [inst_1 : NormedSpace ℝ E] [inst_2 : NormedAddCommGroup F]
[inst_3 : NormedSpace ℝ F] {k : ℕ} {α : ↑unitInterval} {f : E → F} {a : E},
ContDiffAt ℝ (↑k) f a →
((fun x => iteratedFDeriv ℝ k f x - iteratedFDeriv ℝ k f a) =O[nhds a] fun x => ‖x - a‖ ^ ↑... | false |
Stream'.Seq.BisimO.eq_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (R : Stream'.Seq α → Stream'.Seq α → Prop), Stream'.Seq.BisimO R none none = True | true |
FirstOrder.Language.Ultraproduct.term_realize_cast | Mathlib.ModelTheory.Ultraproducts | ∀ {α : Type u_1} {M : α → Type u_2} {u : Ultrafilter α} {L : FirstOrder.Language} [inst : (a : α) → L.Structure (M a)]
{β : Type u_3} (x : β → (a : α) → M a) (t : L.Term β),
FirstOrder.Language.Term.realize (fun i => Quotient.mk' (x i)) t =
Quotient.mk' fun a => FirstOrder.Language.Term.realize (fun i => x i a)... | true |
Num.lt_to_nat | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, ↑m < ↑n ↔ m < n | true |
Turing.PartrecToTM2.trNat_default | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.trNat default = [] | true |
Lean.Meta.Simp.NormCastConfig.decide._inherited_default | Init.MetaTypes | Bool | false |
LinearMap.toContinuousBilinearMap_apply | Mathlib.Topology.Algebra.Module.FiniteDimensionBilinear | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] [inst_1 : CompleteSpace 𝕜] {E : Type u_2} [inst_2 : AddCommGroup E]
[inst_3 : Module 𝕜 E] [inst_4 : TopologicalSpace E] [inst_5 : IsTopologicalAddGroup E] [inst_6 : ContinuousSMul 𝕜 E]
[inst_7 : FiniteDimensional 𝕜 E] [inst_8 : T2Space E] {F : Type u_3} [ins... | true |
List.countP.go._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → ℕ → ℕ | false |
_private.Init.Data.String.Slice.0.String.Slice.SplitIterator.toOption.match_1.splitter | Init.Data.String.Slice | {ρ : Type} →
{σ : String.Slice → Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.ToForwardSearcher pat σ] →
{s : String.Slice} →
(motive : String.Slice.SplitIterator pat s → Sort u_1) →
(x : String.Slice.SplitIterator pat s) →
((currPos : s.Pos) →
... | true |
CategoryTheory.ShortComplex.SnakeInput.naturality_φ₁ | Mathlib.Algebra.Homology.ShortComplex.SnakeLemma | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{v_1, u_1} C] [inst_1 : CategoryTheory.Abelian C]
{S₁ S₂ : CategoryTheory.ShortComplex.SnakeInput C} (f : S₁ ⟶ S₂),
CategoryTheory.CategoryStruct.comp S₁.φ₁ f.f₂.τ₁ =
CategoryTheory.CategoryStruct.comp (CategoryTheory.ShortComplex.SnakeInput.functorP.map f) S₂.φ₁ | true |
CategoryTheory.Limits.Types.Small.limitConeIsLimit._proof_3 | Mathlib.CategoryTheory.Limits.Types.Limits | ∀ {J : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} J] (F : CategoryTheory.Functor J (Type u_1))
[inst_1 : Small.{u_1, max u_1 u_3} ↑F.sections] (x : CategoryTheory.Limits.Cone F)
(x_1 : x.pt ⟶ (CategoryTheory.Limits.Types.Small.limitCone F).pt),
(∀ (j : J),
CategoryTheory.CategoryStruct.comp x_1 ((... | false |
CategoryTheory.CartesianMonoidalCategory.associator_inv_fst_fst | Mathlib.CategoryTheory.Monoidal.Cartesian.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.CartesianMonoidalCategory C]
(X Y Z : C),
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.associator X Y Z).inv
(CategoryTheory.CategoryStruct.comp
(CategoryTheory.SemiCartesianMonoidalCategory.... | true |
Prod.continuousConstSMul | Mathlib.Topology.Algebra.ConstMulAction | ∀ {M : Type u_1} {α : Type u_2} {β : Type u_3} [inst : TopologicalSpace α] [inst_1 : SMul M α] [ContinuousConstSMul M α]
[inst_3 : TopologicalSpace β] [inst_4 : SMul M β] [ContinuousConstSMul M β], ContinuousConstSMul M (α × β) | true |
_private.Init.Data.Iterators.Lemmas.Combinators.Take.0.Std.Iter.step_take.match_1.eq_1 | Init.Data.Iterators.Lemmas.Combinators.Take | ∀ {α β : Type u_1} [inst : Std.Iterator α Id β] {it : Std.Iter β} (motive : it.Step → Sort u_2) (it' : Std.Iter β)
(out : β) (h : it.IsPlausibleStep (Std.IterStep.yield it' out))
(h_1 :
(it' : Std.Iter β) →
(out : β) → (h : it.IsPlausibleStep (Std.IterStep.yield it' out)) → motive ⟨Std.IterStep.yield it' ... | true |
instMinISize | Init.Data.SInt.Basic | Min ISize | true |
Std.ExtTreeMap.getKeyD_insertManyIfNewUnit_list_of_mem | Std.Data.ExtTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {t : Std.ExtTreeMap α Unit cmp} [inst : Std.TransCmp cmp] {l : List α}
{k fallback : α}, k ∈ t → (t.insertManyIfNewUnit l).getKeyD k fallback = t.getKeyD k fallback | true |
ampleSet_empty._simp_1 | Mathlib.Analysis.Convex.AmpleSet | ∀ {F : Type u_1} [inst : AddCommGroup F] [inst_1 : Module ℝ F] [inst_2 : TopologicalSpace F], AmpleSet ∅ = True | false |
SchauderBasis.RankOneDecomposition.mk.noConfusion | Mathlib.Analysis.Normed.Module.Bases | {𝕜 : Type u_1} →
{inst : NontriviallyNormedField 𝕜} →
{X : Type u_2} →
{inst_1 : NormedAddCommGroup X} →
{inst_2 : NormedSpace 𝕜 X} →
{P : Sort u} →
{P_1 : ℕ → X →L[𝕜] X} →
{e : ℕ → X} →
{proj_zero : P_1 0 = 0} →
{finrank_rang... | false |
_private.Mathlib.Analysis.Analytic.IsolatedZeros.0.HasSum.exists_hasSum_smul_of_apply_eq_zero._simp_1_7 | Mathlib.Analysis.Analytic.IsolatedZeros | ∀ {R : Type u_1} [inst : AddMonoidWithOne R] [CharZero R] (n : ℕ), (↑n + 1 = 0) = False | false |
Lean.Meta.ApplyNewGoals.toCtorIdx | Init.Meta.Defs | Lean.Meta.ApplyNewGoals → ℕ | false |
contDiffAt_infty | Mathlib.Analysis.Calculus.ContDiff.Defs | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {E : Type uE} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type uF} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {f : E → F}
{x : E}, ContDiffAt 𝕜 (↑⊤) f x ↔ ∀ (n : ℕ), ContDiffAt 𝕜 (↑n) f x | true |
Int.abs_eq_normalize | Mathlib.Algebra.GCDMonoid.Nat | ∀ (z : ℤ), |z| = normalize z | true |
Set.mk_preimage_sym2 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {s : Set α}, Function.uncurry Sym2.mk ⁻¹' s.sym2 = s ×ˢ s | true |
Set.mapsTo_image_iff._simp_1 | Mathlib.Data.Set.Function | ∀ {α : Type u_1} {β : Type u_2} {γ : Type u_3} {f : α → β} {g : γ → α} {s : Set γ} {t : Set β},
Set.MapsTo f (g '' s) t = Set.MapsTo (f ∘ g) s t | false |
exists_eq'._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {a' : α}, (∃ a, a' = a) = True | false |
String.Slice.Pattern.Model.NoPrefixForwardPatternModel.rec | Init.Data.String.Lemmas.Pattern.Basic | {ρ : Type} →
{pat : ρ} →
[inst : String.Slice.Pattern.Model.ForwardPatternModel pat] →
{motive : String.Slice.Pattern.Model.NoPrefixForwardPatternModel pat → Sort u} →
((eq_empty :
∀ (s t : String),
String.Slice.Pattern.Model.ForwardPatternModel.Matches pat s →
... | false |
WeierstrassCurve.ctorIdx | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → ℕ | false |
Subtype.restrict_injective | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} {f : α → β} (p : α → Prop),
Function.Injective f → Function.Injective (Subtype.restrict p f) | true |
Subsemigroup.unop_le_unop_iff | Mathlib.Algebra.Group.Subsemigroup.MulOpposite | ∀ {M : Type u_2} [inst : Mul M] {S₁ S₂ : Subsemigroup Mᵐᵒᵖ}, S₁.unop ≤ S₂.unop ↔ S₁ ≤ S₂ | true |
Std.DHashMap.Internal.Raw₀.getThenInsertIfNew?_fst | Std.Data.DHashMap.Internal.RawLemmas | ∀ {α : Type u} {β : α → Type v} (m : Std.DHashMap.Internal.Raw₀ α β) [inst : BEq α] [inst_1 : Hashable α]
[inst_2 : LawfulBEq α] {k : α} {v : β k}, (m.getThenInsertIfNew? k v).1 = m.get? k | true |
Lean.Elab.CommandContextInfo.mk._flat_ctor | Lean.Elab.InfoTree.Types | Lean.Environment →
Option Lean.Environment →
Lean.FileMap →
Lean.MetavarContext →
Lean.Options → Lean.Name → List Lean.OpenDecl → Lean.NameGenerator → Lean.Elab.CommandContextInfo | false |
Std.DHashMap.Equiv.isEmpty_eq | Std.Data.DHashMap.Lemmas | ∀ {α : Type u} {β : α → Type v} {x : BEq α} {x_1 : Hashable α} {m₁ m₂ : Std.DHashMap α β} [EquivBEq α]
[LawfulHashable α], m₁.Equiv m₂ → m₁.isEmpty = m₂.isEmpty | true |
_private.Mathlib.Algebra.Homology.SpectralObject.SpectralSequence.0.CategoryTheory.Abelian.SpectralObject.SpectralSequence.HomologyData.isIso_mapFourδ₁Toδ₀'._proof_1_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (pq' : κ) (n₁ n₂ : ℤ),
n₁ = data.deg pq' → n₁ + 1 = n₂ → n₂ = data.deg pq' + 1 | false |
_private.Mathlib.GroupTheory.Perm.Support.0.Equiv.Perm.IsSwap.of_subtype_isSwap.match_1_1 | Mathlib.GroupTheory.Perm.Support | ∀ {α : Type u_1} [inst : DecidableEq α] {p : α → Prop} {f : Equiv.Perm (Subtype p)} (motive : f.IsSwap → Prop)
(h : f.IsSwap),
(∀ (x : α) (hx : p x) (y : α) (hy : p y) (hxy : ⟨x, hx⟩ ≠ ⟨y, hy⟩ ∧ f = Equiv.swap ⟨x, hx⟩ ⟨y, hy⟩), motive ⋯) →
motive h | false |
Batteries.RBNode.ins._sunfold | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → α → Ordering) → α → Batteries.RBNode α → Batteries.RBNode α | false |
ContinuousMap.Homotopy.pi._proof_1 | Mathlib.Topology.Homotopy.Basic | ∀ {X : Type u_1} {ι : Type u_3} [inst : TopologicalSpace X] {Y : ι → Type u_2}
[inst_1 : (i : ι) → TopologicalSpace (Y i)] {f₀ f₁ : (i : ι) → C(X, Y i)} (i : ι),
ContinuousMapClass ((f₀ i).Homotopy (f₁ i)) (↑unitInterval × X) (Y i) | false |
_private.Mathlib.NumberTheory.FrobeniusNumber.0.Nat.exists_mem_span_nat_finset_of_ge.match_1_3 | Mathlib.NumberTheory.FrobeniusNumber | ∀ (s : Set ℕ) (motive : (∃ n ∈ s, n ≠ 0) → Prop) (x : ∃ n ∈ s, n ≠ 0),
(∀ (x : ℕ) (hxs : x ∈ s) (hx : x ≠ 0), motive ⋯) → motive x | false |
Nat.cast_finprod_mem | Mathlib.Algebra.BigOperators.Finprod | ∀ {ι : Type u_3} {s : Set ι},
s.Finite →
∀ {R : Type u_7} [inst : CommSemiring R] (f : ι → ℕ),
↑(∏ᶠ (x : ι) (_ : x ∈ s), f x) = ∏ᶠ (x : ι) (_ : x ∈ s), ↑(f x) | true |
upperClosure_eq_bot | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α}, ¬BddBelow s → upperClosure s = ⊥ | true |
Lean.Doc.instFromDocArgNat | Lean.Elab.DocString | Lean.Doc.FromDocArg ℕ | true |
String.Pos.mk.sizeOf_spec | Init.Data.String.Defs | ∀ {s : String} (offset : String.Pos.Raw) (isValid : String.Pos.Raw.IsValid s offset),
sizeOf { offset := offset, isValid := isValid } = 1 + sizeOf offset + sizeOf isValid | true |
Int64.ne_iff_toBitVec_ne | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, a ≠ b ↔ a.toBitVec ≠ b.toBitVec | true |
NumberField.discr_mem_differentIdeal | Mathlib.NumberTheory.NumberField.Discriminant.Different | ∀ (K : Type u_1) (𝒪 : Type u_2) [inst : Field K] [inst_1 : NumberField K] [inst_2 : CommRing 𝒪] [inst_3 : Algebra 𝒪 K]
[IsFractionRing 𝒪 K] [IsIntegralClosure 𝒪 ℤ K] [inst_6 : IsDedekindDomain 𝒪] [inst_7 : CharZero 𝒪]
[Module.Finite ℤ 𝒪], ↑(NumberField.discr K) ∈ differentIdeal ℤ 𝒪 | true |
CategoryTheory.MonoidalOpposite.noConfusionType | Mathlib.CategoryTheory.Monoidal.Opposite | Sort u → {C : Type u₁} → Cᴹᵒᵖ → {C' : Type u₁} → C'ᴹᵒᵖ → Sort u | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go | Init.Data.Nat.Power2.Basic | ℕ → (power : ℕ) → power > 0 → ℕ | true |
_private.Mathlib.MeasureTheory.Measure.AddContent.0.MeasureTheory.AddContent.onIoc._proof_8 | Mathlib.MeasureTheory.Measure.AddContent | ∀ {α : Type u_1} [inst : LinearOrder α] (v u' v' : α), v ∈ Set.Ioc u' v' → v' ≤ v → v = v' | false |
LieModule.genWeightSpace_neg_zsmul_add_ne_bot | Mathlib.Algebra.Lie.Weights.Chain | ∀ {R : Type u_1} {L : Type u_2} [inst : CommRing R] [inst_1 : LieRing L] [inst_2 : LieAlgebra R L] {M : Type u_3}
[inst_3 : AddCommGroup M] [inst_4 : Module R M] [inst_5 : LieRingModule L M] [inst_6 : LieModule R L M]
[inst_7 : LieRing.IsNilpotent L] [inst_8 : IsAddTorsionFree R] [inst_9 : IsDomain R]
[inst_10 : ... | true |
Int.ediv_mul_add_emod | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a / b * b + a % b = a | true |
String.Pos.offset_add_slice | Init.Data.String.Basic | ∀ {s : String} {p₀ p₁ : s.Pos} {h : p₀ ≤ p₁}, p₀.offset + s.slice p₀ p₁ h = p₁.offset | true |
Nat.max_left_comm | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max a (max b c) = max b (max a c) | true |
Affine.Simplex.height.eq_1 | Mathlib.Geometry.Euclidean.Altitude | ∀ {V : Type u_1} {P : Type u_2} [inst : NormedAddCommGroup V] [inst_1 : InnerProductSpace ℝ V] [inst_2 : MetricSpace P]
[inst_3 : NormedAddTorsor V P] {n : ℕ} [inst_4 : NeZero n] (s : Affine.Simplex ℝ P n) (i : Fin (n + 1)),
s.height i = dist (s.points i) (s.altitudeFoot i) | true |
Aesop.VariableMap.addHyp | Aesop.Forward.State | Aesop.VariableMap → Aesop.Slot → Aesop.Hyp → Aesop.BaseM (Aesop.VariableMap × Bool) | true |
Lean.Elab.Tactic.BVDecide.Frontend.BVCheck.mkContext | Lean.Elab.Tactic.BVDecide.Frontend.BVCheck | System.FilePath →
Lean.Elab.Tactic.BVDecide.Frontend.BVDecideConfig →
Lean.Elab.TermElabM Lean.Elab.Tactic.BVDecide.Frontend.TacticContext | true |
_private.Lean.Meta.Sym.Pattern.0.Lean.Meta.Sym.process.processAppDefault._unsafe_rec | Lean.Meta.Sym.Pattern | Lean.Expr → Lean.Expr → Lean.Meta.Sym.UnifyM✝ Bool | false |
Diffeomorph.prodAssoc._proof_1 | Mathlib.Geometry.Manifold.Diffeomorph | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_3} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_2} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {H : Type u_5}
[inst_5 : TopologicalSpace H] {G : Type u_4} [inst_6 : TopologicalSpace G] {G' : Type u_6}
[ins... | false |
Lean.ImportArtifacts.casesOn | Lean.Setup | {motive : Lean.ImportArtifacts → Sort u} →
(t : Lean.ImportArtifacts) → ((toArray : Array System.FilePath) → motive { toArray := toArray }) → motive t | false |
Std.Tactic.BVDecide.BVExpr.bitblast.FullAdderInput.mk.inj | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Add | ∀ {α : Type} {inst : Hashable α} {inst_1 : DecidableEq α} {aig : Std.Sat.AIG α}
{lhs rhs cin lhs_1 rhs_1 cin_1 : aig.Ref},
{ lhs := lhs, rhs := rhs, cin := cin } = { lhs := lhs_1, rhs := rhs_1, cin := cin_1 } →
lhs = lhs_1 ∧ rhs = rhs_1 ∧ cin = cin_1 | true |
LipschitzWith.edist_lt_top | Mathlib.Topology.EMetricSpace.Lipschitz | ∀ {α : Type u} {β : Type v} [inst : PseudoEMetricSpace α] [inst_1 : PseudoEMetricSpace β] {K : NNReal} {f : α → β},
LipschitzWith K f → ∀ {x y : α}, edist x y ≠ ⊤ → edist (f x) (f y) < ⊤ | true |
CategoryTheory.ProjectiveResolution.noConfusion | Mathlib.CategoryTheory.Preadditive.Projective.Resolution | {P : Sort u_1} →
{C : Type u} →
{inst : CategoryTheory.Category.{v, u} C} →
{inst_1 : CategoryTheory.Limits.HasZeroObject C} →
{inst_2 : CategoryTheory.Limits.HasZeroMorphisms C} →
{Z : C} →
{t : CategoryTheory.ProjectiveResolution Z} →
{C' : Type u} →
... | false |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.zeroThm? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Option (Option Lean.Expr) | true |
_private.Mathlib.Data.PFun.0.PFun.fix.match_1.eq_2 | Mathlib.Data.PFun | ∀ {α : Type u_2} {β : Type u_1} (motive : β ⊕ α → Sort u_3) (a' : α)
(h_1 : (b : β) → Sum.inr a' = Sum.inl b → motive (Sum.inl b))
(h_2 : (a'_1 : α) → Sum.inr a' = Sum.inr a'_1 → motive (Sum.inr a'_1)),
(match e : Sum.inr a' with
| Sum.inl b => h_1 b e
| Sum.inr a'_1 => h_2 a'_1 e) =
h_2 a' ⋯ | true |
CategoryTheory.MonoidalClosed.uncurry_pre_app_assoc | Mathlib.CategoryTheory.Monoidal.Closed.Basic | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.MonoidalCategory C] {A B : C} (X : C)
{Y : C} [inst_2 : CategoryTheory.Closed A] [inst_3 : CategoryTheory.Closed B] (f : Y ⟶ A ⟹ X) (g : B ⟶ A) {Z : C}
(h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp
(CategoryTheory.MonoidalCl... | true |
WeierstrassCurve.Affine.Point.toProjective | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Point | {R : Type r} →
[inst : CommRing R] →
[Nontrivial R] → {W : WeierstrassCurve.Affine R} → W.Point → (WeierstrassCurve.toProjective W).Point | true |
List.erase_eq_eraseTR | Init.Data.List.Impl | @List.erase = @List.eraseTR | true |
Algebra.intTraceAux._proof_4 | Mathlib.RingTheory.IntegralClosure.IntegralRestrict | ∀ (A : Type u_3) (K : Type u_2) (L : Type u_1) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra A K] [inst_4 : Algebra K L] [inst_5 : Algebra A L] [IsScalarTower A K L],
LinearMap.CompatibleSMul L K A K | false |
_private.Lean.Elab.Structure.0.Lean.Elab.Command.Structure.instReprStructFieldDefault.repr.match_1 | Lean.Elab.Structure | (motive : Lean.Elab.Command.Structure.StructFieldDefault → Sort u_1) →
(x : Lean.Elab.Command.Structure.StructFieldDefault) →
((a : Lean.Expr) → motive (Lean.Elab.Command.Structure.StructFieldDefault.optParam a)) →
((a : Lean.Expr) → motive (Lean.Elab.Command.Structure.StructFieldDefault.autoParam a)) → mot... | false |
WittVector.instAddCommGroupStandardOneDimIsocrystal._proof_11 | Mathlib.RingTheory.WittVector.Isocrystal | ∀ (p : ℕ) [inst : Fact (Nat.Prime p)] (k : Type u_1) [inst_1 : CommRing k] (_m : ℤ),
autoParam
(∀ (n : ℕ) (x : WittVector.StandardOneDimIsocrystal p k _m),
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8 p k _m (n + 1) x =
WittVector.instAddCommGroupStandardOneDimIsocrystal._aux_8 p k _m ... | false |
Lean.Grind.instCommRingInt64._proof_3 | Init.GrindInstances.Ring.SInt | ∀ (i : ℤ) (x : Int64), -i • x = -(i • x) | false |
ComplexShape.rel_π₁ | 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₁₂] {i₁ i₁' : I₁},
c₁.Rel i₁ i₁' → ∀ (i₂ : I₂), c₁₂.Rel (c₁.π c₂ c₁₂ (i₁, i₂)) (c₁.π c₂ c₁₂ (i₁', i₂)) | true |
Submonoid.coe_pos | Mathlib.Algebra.Order.GroupWithZero.Submonoid | ∀ (α : Type u_1) [inst : MulZeroOneClass α] [inst_1 : PartialOrder α] [inst_2 : PosMulStrictMono α]
[inst_3 : ZeroLEOneClass α] [inst_4 : NeZero 1], ↑(Submonoid.pos α) = Set.Ioi 0 | true |
Aesop.UnorderedArraySet.empty | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → Aesop.UnorderedArraySet α | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.visitNamespace._sunfold | Lean.Elab.DeclNameGen | Lean.Name → Lean.Elab.Command.NameGen.MkNameM✝ Unit | false |
Nat.Primrec | Mathlib.Computability.Primrec.Basic | (ℕ → ℕ) → Prop | true |
ConvexOn.secant_mono_aux1 | Mathlib.Analysis.Convex.Slope | ∀ {𝕜 : Type u_1} [inst : Field 𝕜] [inst_1 : LinearOrder 𝕜] [IsStrictOrderedRing 𝕜] {s : Set 𝕜} {f : 𝕜 → 𝕜},
ConvexOn 𝕜 s f → ∀ {x y z : 𝕜}, x ∈ s → z ∈ s → x < y → y < z → (z - x) * f y ≤ (z - y) * f x + (y - x) * f z | true |
MvPolynomial.evalᵢ.eq_1 | Mathlib.FieldTheory.Finite.Polynomial | ∀ (σ K : Type u) [inst : Fintype K] [inst_1 : CommRing K],
MvPolynomial.evalᵢ σ K = MvPolynomial.evalₗ K σ ∘ₗ (MvPolynomial.restrictDegree σ K (Fintype.card K - 1)).subtype | true |
Matrix.diagonal_tsum | Mathlib.Topology.Instances.Matrix | ∀ {X : Type u_1} {n : Type u_5} {R : Type u_8} [inst : AddCommMonoid R] [inst_1 : TopologicalSpace R]
{L : SummationFilter X} [inst_2 : DecidableEq n] [T2Space R] {f : X → n → R},
Matrix.diagonal (∑'[L] (x : X), f x) = ∑'[L] (x : X), Matrix.diagonal (f x) | true |
Array.getElem_insertIdx_of_lt | Init.Data.Array.InsertIdx | ∀ {α : Type u} {xs : Array α} {x : α} {i k : ℕ} (w : i ≤ xs.size) (h : k < i), (xs.insertIdx i x w)[k] = xs[k] | true |
Lean.Parser.ParserExtension.instInhabitedEntry.default | Lean.Parser.Extension | Lean.Parser.ParserExtension.Entry | true |
OrderIso.isLUB_preimage._simp_1 | Mathlib.Order.Bounds.OrderIso | ∀ {α : Type u_1} {β : Type u_2} [inst : Preorder α] [inst_1 : Preorder β] (f : α ≃o β) {s : Set β} {x : α},
IsLUB (⇑f ⁻¹' s) x = IsLUB s (f x) | false |
le_bot_iff._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | false |
Lean.Meta.Grind.Arith.Cutsat.Search.State.recOn | Lean.Meta.Tactic.Grind.Arith.Cutsat.SearchM | {motive : Lean.Meta.Grind.Arith.Cutsat.Search.State → Sort u} →
(t : Lean.Meta.Grind.Arith.Cutsat.Search.State) →
((cases : Lean.PArray Lean.Meta.Grind.Arith.Cutsat.Case) →
(precise : Bool) →
(decVars : Lean.FVarIdSet) → motive { cases := cases, precise := precise, decVars := decVars }) →
... | false |
_private.Init.Data.String.Defs.0.String.append_left_inj._simp_1_1 | Init.Data.String.Defs | ∀ {s t : String}, (s = t) = (s.toByteArray = t.toByteArray) | false |
Lean.Elab.Term.Do.homogenize | Lean.Elab.Do.Legacy | Lean.Elab.Term.Do.CodeBlock →
Lean.Elab.Term.Do.CodeBlock → Lean.Elab.TermElabM (Lean.Elab.Term.Do.CodeBlock × Lean.Elab.Term.Do.CodeBlock) | true |
Std.DHashMap.Raw.mem_of_mem_filterMap | Std.Data.DHashMap.RawLemmas | ∀ {α : Type u} {β : α → Type v} {γ : α → Type w} [inst : BEq α] [inst_1 : Hashable α] {m : Std.DHashMap.Raw α β}
[EquivBEq α] [LawfulHashable α] {f : (a : α) → β a → Option (γ a)} {k : α},
m.WF → k ∈ Std.DHashMap.Raw.filterMap f m → k ∈ m | true |
CategoryTheory.curriedYonedaLemma._proof_3 | Mathlib.CategoryTheory.Yoneda | ∀ {C : Type u_1} [inst : CategoryTheory.SmallCategory C] {X Y : Cᵒᵖ} (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp ((CategoryTheory.yoneda.op.comp CategoryTheory.coyoneda).map f)
((fun X => CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.yonedaEquiv.toIso) ⋯) Y).hom =
CategoryTheory.CategorySt... | false |
lp.instModulePreLp._proof_5 | Mathlib.Analysis.Normed.Lp.lpSpace | ∀ {𝕜 : Type u_3} {α : Type u_1} {E : α → Type u_2} [inst : (i : α) → NormedAddCommGroup (E i)] [inst_1 : NormedRing 𝕜]
[inst_2 : (i : α) → Module 𝕜 (E i)] (a : 𝕜), a • 0 = 0 | false |
Lean.Grind.CommRing.Poly.pow.match_1 | Init.Grind.Ring.CommSolver | (motive : ℕ → Sort u_1) → (k : ℕ) → (Unit → motive 0) → (Unit → motive 1) → ((k : ℕ) → motive k.succ) → motive k | false |
Lean.Elab.Tactic.evalIntro | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | true |
SSet.StrictSegal._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} → X.StrictSegal → ℕ | false |
Finset.max'_lt_iff._simp_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_2} [inst : LinearOrder α] (s : Finset α) (H : s.Nonempty) {x : α}, (s.max' H < x) = ∀ y ∈ s, y < x | false |
Module.DirectLimit.addCommMonoid._proof_3 | Mathlib.Algebra.Colimit.Module | ∀ {R : Type u_1} [inst : Semiring R] {ι : Type u_2} [inst_1 : Preorder ι] (G : ι → Type u_3)
[inst_2 : (i : ι) → AddCommMonoid (G i)] [inst_3 : (i : ι) → Module R (G i)] (f : (i j : ι) → i ≤ j → G i →ₗ[R] G j)
[inst_4 : DecidableEq ι] (a b c : Module.DirectLimit G f), a + b + c = a + (b + c) | false |
_private.Mathlib.Topology.MetricSpace.Infsep.0.Set.Finite.einfsep._simp_1_5 | Mathlib.Topology.MetricSpace.Infsep | ∀ {α : Type u} {x : α × α} {s : Set α}, (x ∈ s.offDiag) = (x.1 ∈ s ∧ x.2 ∈ s ∧ x.1 ≠ x.2) | false |
CategoryTheory.Abelian.Ext.mk₀_smul | Mathlib.Algebra.Homology.DerivedCategory.Ext.Linear | ∀ {R : Type t} [inst : Ring R] {C : Type u} [inst_1 : CategoryTheory.Category.{v, u} C]
[inst_2 : CategoryTheory.Abelian C] [inst_3 : CategoryTheory.Linear R C] [inst_4 : CategoryTheory.HasExt C] {X Y : C}
(r : R) (f : X ⟶ Y), CategoryTheory.Abelian.Ext.mk₀ (r • f) = r • CategoryTheory.Abelian.Ext.mk₀ f | true |
Lean.Widget.DiffTag.willInsert.sizeOf_spec | Lean.Widget.InteractiveCode | sizeOf Lean.Widget.DiffTag.willInsert = 1 | true |
List.reduceOption_length_le | Mathlib.Data.List.ReduceOption | ∀ {α : Type u_1} (l : List (Option α)), l.reduceOption.length ≤ l.length | true |
spectralNorm.spectralNorm_pow_natDegree_eq_prod_roots | Mathlib.Analysis.Normed.Unbundled.SpectralNorm | ∀ (K : Type u) [inst : NontriviallyNormedField K] (L : Type v) [inst_1 : Field L] [inst_2 : Algebra K L]
[hu : IsUltrametricDist K] [inst_3 : CompleteSpace K] (x : L) {E : Type u_2} [inst_4 : Field E] [inst_5 : Algebra K E]
[inst_6 : Algebra L E] [IsScalarTower K L E] [Polynomial.IsSplittingField L E ((Polynomial.m... | true |
HomotopicalAlgebra.PathObject.weakEquivalence_ι | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] [inst_1 : HomotopicalAlgebra.CategoryWithWeakEquivalences C]
{A : C} (self : HomotopicalAlgebra.PathObject A), HomotopicalAlgebra.WeakEquivalence self.ι | true |
Ordnode.erase._sunfold | Mathlib.Data.Ordmap.Ordnode | {α : Type u_1} → [inst : LE α] → [DecidableLE α] → α → Ordnode α → Ordnode α | false |
QuadraticMap.mk.sizeOf_spec | Mathlib.LinearAlgebra.QuadraticForm.Basic | ∀ {R : Type u} {M : Type v} {N : Type w} [inst : CommSemiring R] [inst_1 : AddCommMonoid M] [inst_2 : Module R M]
[inst_3 : AddCommMonoid N] [inst_4 : Module R N] [inst_5 : SizeOf R] [inst_6 : SizeOf M] [inst_7 : SizeOf N]
(toFun : M → N) (toFun_smul : ∀ (a : R) (x : M), toFun (a • x) = (a * a) • toFun x)
(exists... | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.