name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M |
|---|---|---|
Batteries.Tactic.exacts | Batteries.Tactic.Init | Lean.ParserDescr |
Matroid.eRk_union_le_eRk_add_encard | Mathlib.Combinatorics.Matroid.Rank.ENat | ∀ {α : Type u_1} (M : Matroid α) (X Y : Set α), M.eRk (X ∪ Y) ≤ M.eRk X + Y.encard |
Lean.Parser.Term.doIf._regBuiltin.Lean.Parser.Term.doIf.parenthesizer_51 | Lean.Parser.Do | IO Unit |
Std.ExtDTreeMap.Const.get!_diff | Std.Data.ExtDTreeMap.Lemmas | ∀ {α : Type u} {cmp : α → α → Ordering} {β : Type v} {t₁ t₂ : Std.ExtDTreeMap α (fun x => β) cmp}
[inst : Std.TransCmp cmp] [inst_1 : Inhabited β] {k : α},
Std.ExtDTreeMap.Const.get! (t₁ \ t₂) k = if k ∈ t₂ then default else Std.ExtDTreeMap.Const.get! t₁ k |
_private.Mathlib.SetTheory.Lists.0.Lists'.toList.match_1.splitter | Mathlib.SetTheory.Lists | {α : Type u_1} →
(motive : (x : Bool) → Lists' α x → Sort u_2) →
(x : Bool) →
(x_1 : Lists' α x) →
((a : α) → motive false (Lists'.atom a)) →
(Unit → motive true Lists'.nil) →
((b : Bool) → (a : Lists' α b) → (l : Lists' α true) → motive true (a.cons' l)) → motive x x_1 |
Topology.scottHausdorff | Mathlib.Topology.Order.ScottTopology | (α : Type u_3) → Set (Set α) → [Preorder α] → TopologicalSpace α |
MeasureTheory.fundamentalInterior.eq_1 | Mathlib.MeasureTheory.Group.FundamentalDomain | ∀ (G : Type u_1) {α : Type u_3} [inst : Group G] [inst_1 : MulAction G α] (s : Set α),
MeasureTheory.fundamentalInterior G s = s \ ⋃ g, ⋃ (_ : g ≠ 1), g • s |
Unitization.quasispectrum_eq_spectrum_inr | Mathlib.Algebra.Algebra.Spectrum.Quasispectrum | ∀ (R : Type u_3) {A : Type u_4} [inst : CommRing R] [inst_1 : NonUnitalRing A] [inst_2 : Module R A]
[inst_3 : IsScalarTower R A A] [inst_4 : SMulCommClass R A A] (a : A), quasispectrum R a = spectrum R ↑a |
Std.Time.Modifier.s.inj | Std.Time.Format.Basic | ∀ {presentation presentation_1 : Std.Time.Number},
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation_1 → presentation = presentation_1 |
CategoryTheory.instInhabitedIsSplitCoequalizerId._proof_1 | Mathlib.CategoryTheory.Limits.Shapes.SplitCoequalizer | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X : C},
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) =
CategoryTheory.CategoryStruct.comp (CategoryTheory.CategoryStruct.id X) (CategoryTheory.CategoryStruct.id X) |
_private.Init.Data.BitVec.Lemmas.0.BitVec.getMsbD_intMin.match_1_1 | Init.Data.BitVec.Lemmas | ∀ (motive : ℕ → ℕ → Prop) (w i : ℕ),
(∀ (x : ℕ), motive 0 x) → (∀ (w : ℕ), motive w.succ 0) → (∀ (w i : ℕ), motive w.succ i.succ) → motive w i |
Lean.Meta.SynthInstance.SubgoalsResult | Lean.Meta.SynthInstance | Type |
CircleDeg1Lift.semiconj_of_isUnit_of_translationNumber_eq | Mathlib.Dynamics.Circle.RotationNumber.TranslationNumber | ∀ {f₁ f₂ : CircleDeg1Lift},
IsUnit f₁ → IsUnit f₂ → f₁.translationNumber = f₂.translationNumber → ∃ F, Function.Semiconj ⇑F ⇑f₁ ⇑f₂ |
CategoryTheory.Bicategory.HasAbsLeftKanLift.mk._flat_ctor | Mathlib.CategoryTheory.Bicategory.Kan.HasKan | ∀ {B : Type u} [inst : CategoryTheory.Bicategory B] {a b c : B} {f : b ⟶ a} {g : c ⟶ a}
(hasInitial : CategoryTheory.Limits.HasInitial (CategoryTheory.Bicategory.LeftLift f g)),
(∀ {x : B} (h : x ⟶ c), CategoryTheory.Bicategory.LanLift.CommuteWith f g h) →
CategoryTheory.Bicategory.HasAbsLeftKanLift f g |
Nat.Partrec.Code.pair.noConfusion | Mathlib.Computability.PartrecCode | {P : Sort u} → {a a_1 a' a'_1 : Nat.Partrec.Code} → a.pair a_1 = a'.pair a'_1 → (a = a' → a_1 = a'_1 → P) → P |
Compactum.join_distrib | Mathlib.Topology.Category.Compactum | ∀ (X : Compactum) (uux : Ultrafilter (Ultrafilter X.A)), X.str (X.join uux) = X.str (Ultrafilter.map X.str uux) |
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) =
CategoryTheory.CategoryStruct.comp
(CategoryTheory.Bicategory.InducedBicategory.isoMk (CategoryTheory.Bicategory.leftUnitor f.hom)).hom
(CategoryTheory.CategoryStruct.comp η
(CategoryTheory.Bicategory.InducedBicategory.isoMk (CategoryTheory.Bicategory.leftUnitor g.hom)).inv) |
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‖ ^ ↑α) →
ContDiffPointwiseHolderAt k α f a |
Stream'.Seq.BisimO.eq_1 | Mathlib.Data.Seq.Defs | ∀ {α : Type u} (R : Stream'.Seq α → Stream'.Seq α → Prop), Stream'.Seq.BisimO R none none = 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) t |
Num.lt_to_nat | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, ↑m < ↑n ↔ m < n |
Turing.PartrecToTM2.trNat_default | Mathlib.Computability.TMToPartrec | Turing.PartrecToTM2.trNat default = [] |
Lean.Meta.Simp.NormCastConfig.decide._inherited_default | Init.MetaTypes | Bool |
List.countP.go._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → ℕ → ℕ |
_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) →
(s_1 : Std.Iter (String.Slice.Pattern.SearchStep s)) →
motive (String.Slice.SplitIterator.operating currPos s_1)) →
(Unit → motive String.Slice.SplitIterator.atEnd) → motive x |
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₂.φ₁ |
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 ((CategoryTheory.Limits.Types.Small.limitCone F).π.app j) = x.π.app j) →
x_1 = fun v => (equivShrink ↑F.sections) ⟨fun j => x.π.app j v, ⋯⟩ |
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.fst (CategoryTheory.MonoidalCategoryStruct.tensorObj X Y) Z)
(CategoryTheory.SemiCartesianMonoidalCategory.fst X Y)) =
CategoryTheory.SemiCartesianMonoidalCategory.fst X (CategoryTheory.MonoidalCategoryStruct.tensorObj Y Z) |
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 (α × β) |
_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' out, h⟩)
(h_2 : (it' : Std.Iter β) → (h : it.IsPlausibleStep (Std.IterStep.skip it')) → motive ⟨Std.IterStep.skip it', h⟩)
(h_3 : (h : it.IsPlausibleStep Std.IterStep.done) → motive ⟨Std.IterStep.done, h⟩),
(match ⟨Std.IterStep.yield it' out, h⟩ with
| ⟨Std.IterStep.yield it' out, h⟩ => h_1 it' out h
| ⟨Std.IterStep.skip it', h⟩ => h_2 it' h
| ⟨Std.IterStep.done, h⟩ => h_3 h) =
h_1 it' out h |
instMinISize | Init.Data.SInt.Basic | Min ISize |
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 |
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 |
_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 |
Lean.Meta.ApplyNewGoals.toCtorIdx | Init.Meta.Defs | Lean.Meta.ApplyNewGoals → ℕ |
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 |
Int.abs_eq_normalize | Mathlib.Algebra.GCDMonoid.Nat | ∀ (z : ℤ), |z| = normalize z |
Set.mk_preimage_sym2 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {s : Set α}, Function.uncurry Sym2.mk ⁻¹' s.sym2 = s ×ˢ s |
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 |
exists_eq'._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {a' : α}, (∃ a, a' = a) = True |
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 →
String.Slice.Pattern.Model.ForwardPatternModel.Matches pat (s ++ t) → t = "") →
motive ⋯) →
(t : String.Slice.Pattern.Model.NoPrefixForwardPatternModel pat) → motive t |
WeierstrassCurve.ctorIdx | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → ℕ |
Subtype.restrict_injective | Mathlib.Data.Subtype | ∀ {α : Sort u_4} {β : Type u_5} {f : α → β} (p : α → Prop),
Function.Injective f → Function.Injective (Subtype.restrict p f) |
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₂ |
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 |
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 |
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 |
_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 |
Batteries.RBNode.ins._sunfold | Batteries.Data.RBMap.Basic | {α : Type u_1} → (α → α → Ordering) → α → Batteries.RBNode α → Batteries.RBNode α |
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) |
_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 |
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) |
upperClosure_eq_bot | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α}, ¬BddBelow s → upperClosure s = ⊥ |
Lean.Doc.instFromDocArgNat | Lean.Elab.DocString | Lean.Doc.FromDocArg ℕ |
Int64.ne_iff_toBitVec_ne | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, a ≠ b ↔ a.toBitVec ≠ b.toBitVec |
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 |
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 ℤ 𝒪 |
CategoryTheory.MonoidalOpposite.noConfusionType | Mathlib.CategoryTheory.Monoidal.Opposite | Sort u → {C : Type u₁} → Cᴹᵒᵖ → {C' : Type u₁} → C'ᴹᵒᵖ → Sort u |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go | Init.Data.Nat.Power2.Basic | ℕ → (power : ℕ) → power > 0 → ℕ |
_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' |
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 : Module.IsTorsionFree R M] [inst_11 : IsNoetherian R M] (α : L → R) (β : LieModule.Weight R L M) {n : ℕ},
n ≤ LieModule.chainBotCoeff α β → LieModule.genWeightSpace M (-↑n • α + ⇑β) ≠ ⊥ |
Int.ediv_mul_add_emod | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a / b * b + a % b = a |
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 |
CategoryTheory.PreGaloisCategory.instMulActionAutFunctorFintypeCatCarrierObj._proof_2 | Mathlib.CategoryTheory.Galois.Basic | ∀ {C : Type u_3} [inst : CategoryTheory.Category.{u_2, u_3} C] (F : CategoryTheory.Functor C FintypeCat) (X : C)
(x : (F.obj X).carrier), 1 • x = 1 • x |
Nat.max_left_comm | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max a (max b c) = max b (max a c) |
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) |
Aesop.VariableMap.addHyp | Aesop.Forward.State | Aesop.VariableMap → Aesop.Slot → Aesop.Hyp → Aesop.BaseM (Aesop.VariableMap × Bool) |
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 |
_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 |
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}
[inst_7 : TopologicalSpace G'] (I : ModelWithCorners 𝕜 E H) (J : ModelWithCorners 𝕜 F G)
(J' : ModelWithCorners 𝕜 F G') (M : Type u_8) [inst_8 : TopologicalSpace M] [inst_9 : ChartedSpace H M] (N : Type u_7)
[inst_10 : TopologicalSpace N] [inst_11 : ChartedSpace G N] (N' : Type u_9) [inst_12 : TopologicalSpace N']
[inst_13 : ChartedSpace G' N'] (n : WithTop ℕ∞),
ContMDiff ((I.prod J).prod J') (I.prod (J.prod J')) n fun x => ((Prod.fst ∘ Prod.fst) x, x.1.2, x.2) |
Lean.ImportArtifacts.casesOn | Lean.Setup | {motive : Lean.ImportArtifacts → Sort u} →
(t : Lean.ImportArtifacts) → ((toArray : Array System.FilePath) → motive { toArray := toArray }) → motive t |
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 |
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) < ⊤ |
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} →
{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 = C' →
inst ≍ inst' →
inst_1 ≍ inst'_1 →
inst_2 ≍ inst'_2 →
Z ≍ Z' → t ≍ t' → CategoryTheory.ProjectiveResolution.noConfusionType P t t' |
Lean.Meta.Grind.Arith.Cutsat.ToIntInfo.zeroThm? | Lean.Meta.Tactic.Grind.Arith.Cutsat.ToIntInfo | Lean.Meta.Grind.Arith.Cutsat.ToIntInfo → Option (Option Lean.Expr) |
_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' ⋯ |
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.MonoidalClosed.uncurry
(CategoryTheory.CategoryStruct.comp f ((CategoryTheory.MonoidalClosed.pre g).app X)))
h =
CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalCategoryStruct.whiskerRight g Y)
(CategoryTheory.CategoryStruct.comp (CategoryTheory.MonoidalClosed.uncurry f) h) |
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 |
List.erase_eq_eraseTR | Init.Data.List.Impl | @List.erase = @List.eraseTR |
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 |
_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)) → motive x |
Lean.Grind.instCommRingInt64._proof_3 | Init.GrindInstances.Ring.SInt | ∀ (i : ℤ) (x : Int64), -i • x = -(i • x) |
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₂)) |
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 |
Aesop.UnorderedArraySet.empty | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → Aesop.UnorderedArraySet α |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.visitNamespace._sunfold | Lean.Elab.DeclNameGen | Lean.Name → Lean.Elab.Command.NameGen.MkNameM✝ Unit |
Nat.Primrec | Mathlib.Computability.Primrec.Basic | (ℕ → ℕ) → Prop |
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 |
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 |
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) |
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] |
Lean.Parser.ParserExtension.instInhabitedEntry.default | Lean.Parser.Extension | Lean.Parser.ParserExtension.Entry |
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) |
le_bot_iff._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) |
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 }) →
motive t |
_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) |
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) |
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 |
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.CategoryStruct.comp
((fun X => CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.yonedaEquiv.toIso) ⋯) X).hom
((CategoryTheory.evaluation Cᵒᵖ (Type u_1)).map f) |
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 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.