name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
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 | null | true |
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 | null | true |
Std.Time.Modifier.s.inj | Std.Time.Format.Modifier | ∀ {presentation presentation_1 : Std.Time.Number},
Std.Time.Modifier.s presentation = Std.Time.Modifier.s presentation_1 → presentation = presentation_1 | null | true |
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) | null | false |
_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 | null | false |
Std.WP.Spec.IterM.forIn_filterWithPostcondition | Std.WP.Triple.SpecLemmas | ∀ {α β γ : Type w} {m : Type w → Type w'} {n : Type w → Type w''} {o : Type w → Type w'''} {Pred : Type uₚ}
{EPred : Type uₑ} [inst : Monad m] [LawfulMonad m] [inst_2 : Monad n] [LawfulMonad n] [inst_4 : Monad o]
[inst_5 : Std.WP.Assertion Pred] [inst_6 : Std.WP.Assertion EPred] [inst_7 : Std.WP.WPMonad o Pred EPre... | null | true |
Lean.Meta.SynthInstance.SubgoalsResult | Lean.Meta.SynthInstance | Type | See `getSubgoals` and `getSubgoalsAux`
We use the parameter `j` to reduce the number of `instantiate*` invocations.
It is the same approach we use at `forallTelescope` and `lambdaTelescope`.
Given `getSubgoalsAux args j subgoals instVal type`,
we have that `type.instantiateRevRange j args.size args` does not have loos... | true |
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₂ | If two lifts of circle homeomorphisms have the same translation number, then they are
semiconjugate by a `CircleDeg1Lift`. This version uses assumptions `IsUnit f₁` and `IsUnit f₂`
to assume that `f₁` and `f₂` are homeomorphisms. | true |
instMonoidalClosedSheafOfHasSheafifyOfFunctorOpposite._proof_5 | Mathlib.CategoryTheory.Sites.CartesianClosed | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_4, u_1} C] (J : CategoryTheory.GrothendieckTopology C)
(A : Type u_3) [inst_1 : CategoryTheory.Category.{u_2, u_3} A] [CategoryTheory.HasSheafify J A]
[inst_3 : CategoryTheory.CartesianMonoidalCategory A]
[inst_4 : CategoryTheory.MonoidalClosed (CategoryTheory.F... | null | false |
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 | null | false |
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 | null | false |
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) | null | true |
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... | null | 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‖ ^ ↑... | null | 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 | null | 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)... | null | true |
Num.lt_to_nat | Mathlib.Data.Num.Lemmas | ∀ {m n : Num}, ↑m < ↑n ↔ m < n | null | true |
Turing.PartrecToTM2.trNat_default | Mathlib.Computability.TuringMachine.ToPartrec | Turing.PartrecToTM2.trNat default = [] | null | true |
Lean.Meta.Simp.NormCastConfig.decide._inherited_default | Init.MetaTypes | Bool | null | 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... | null | true |
List.countP.go._unsafe_rec | Init.Data.List.Basic | {α : Type u} → (α → Bool) → List α → ℕ → ℕ | null | 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) →
... | null | 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₂.φ₁ | null | 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 ((... | null | 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.... | null | 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 (α × β) | null | 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' ... | null | true |
instMinISize | Init.Data.SInt.Basic | Min ISize | null | true |
MeasureTheory.stoppedValue_const_smul | Mathlib.Probability.Process.Stopping | ∀ {Ω : Type u_1} {β : Type u_2} {ι : Type u_3} [inst : Nonempty ι] {u : ι → Ω → β} {τ : Ω → WithTop ι} {𝕜 : Type u_4}
[inst_1 : SMul 𝕜 β] (c : 𝕜), MeasureTheory.stoppedValue (c • u) τ = c • MeasureTheory.stoppedValue u τ | null | 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 | null | 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 | null | false |
_private.Mathlib.Topology.Compactness.CompactlyCoherentSpace.0.CompactCoherentification.isClosed_iff._simp_1_1 | Mathlib.Topology.Compactness.CompactlyCoherentSpace | ∀ {α : Type u_1} {β : Type u_2} {t : TopologicalSpace α} {s : Set β} {f : α → β}, IsClosed s = IsClosed (f ⁻¹' s) | null | 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... | null | 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 | null | true |
Int.abs_eq_normalize | Mathlib.Algebra.GCDMonoid.Nat | ∀ (z : ℤ), |z| = normalize z | null | true |
Set.mk_preimage_sym2 | Mathlib.Data.Sym.Sym2 | ∀ {α : Type u_1} {s : Set α}, Function.uncurry Sym2.mk ⁻¹' s.sym2 = s ×ˢ s | null | 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 | null | false |
exists_eq'._simp_1 | Init.PropLemmas | ∀ {α : Sort u_1} {a' : α}, (∃ a, a' = a) = True | null | false |
WeierstrassCurve.ctorIdx | Mathlib.AlgebraicGeometry.EllipticCurve.Weierstrass | {R : Type u} → WeierstrassCurve R → ℕ | null | 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) | null | 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₂ | null | 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 | null | 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 | null | 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 | null | 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 | null | 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 | null | 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) | null | 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 | null | 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) | null | true |
upperClosure_eq_bot | Mathlib.Order.UpperLower.Closure | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Set α}, ¬BddBelow s → upperClosure s = ⊥ | null | true |
Lean.Doc.instFromDocArgNat | Lean.Elab.DocString | Lean.Doc.FromDocArg ℕ | null | 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 | null | true |
Int64.ne_iff_toBitVec_ne | Init.Data.SInt.Lemmas | ∀ {a b : Int64}, a ≠ b ↔ a.toBitVec ≠ b.toBitVec | null | 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] [inst_5 : IsDedekindDomain 𝒪] [inst_6 : CharZero 𝒪] [Module.Finite ℤ 𝒪],
↑(NumberField.discr K) ∈ differentIdeal ℤ 𝒪 | null | true |
CategoryTheory.MonoidalOpposite.noConfusionType | Mathlib.CategoryTheory.Monoidal.Opposite | Sort u → {C : Type u₁} → Cᴹᵒᵖ → {C' : Type u₁} → C'ᴹᵒᵖ → Sort u | null | false |
_private.Init.Data.Nat.Power2.Basic.0.Nat.nextPowerOfTwo.go | Init.Data.Nat.Power2.Basic | ℕ → (power : ℕ) → power > 0 → ℕ | null | 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' | null | 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 : HasUniqueDiv R] [inst_9 : IsDomain R] [inst_10 : Module... | null | true |
Int.ediv_mul_add_emod | Init.Data.Int.DivMod.Bootstrap | ∀ (a b : ℤ), a / b * b + a % b = a | null | 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 | null | true |
Nat.max_left_comm | Init.Data.Nat.Lemmas | ∀ (a b c : ℕ), max a (max b c) = max b (max a c) | null | 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) | null | true |
Aesop.VariableMap.addHyp | Aesop.Forward.State | Aesop.VariableMap → Aesop.Slot → Aesop.Hyp → Aesop.BaseM (Aesop.VariableMap × Bool) | Add a hypothesis `hyp`. Precondition: `hyp` matches the premise of slot
`slot` with substitution `hyp.subst` (and hence `hyp.subst` contains a mapping
for each variable in `slot.common`). Returns `true` if the variable map
changed. | 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 | null | 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... | null | false |
ContinuousAlternatingMap.contMDiff | Mathlib.Geometry.Manifold.ContMDiff.NormedSpace | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {E : Type u_2} [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E] {F : Type u_6} [inst_3 : NormedAddCommGroup F] [inst_4 : NormedSpace 𝕜 F] {n : WithTop ℕ∞}
{ι : Type u_12} [inst_5 : Fintype ι] (L : E [⋀^ι]→L[𝕜] F),
ContMDiff (modelWithCornersSelf �... | null | true |
Lean.ImportArtifacts.casesOn | Lean.Setup | {motive : Lean.ImportArtifacts → Sort u} →
(t : Lean.ImportArtifacts) → ((toArrays : Array (Array System.FilePath)) → motive { toArrays := toArrays }) → motive t | null | 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 | null | true |
DiscreteConvolution.«term_⋆ᵣ_» | Mathlib.Topology.Algebra.InfiniteSum.DiscreteConvolution | Lean.TrailingParserDescr | Notation for convolution using multiplication to combine values. | 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) < ⊤ | null | 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} →
... | null | false |
_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' ⋯ | null | 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... | null | 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 | An abbreviation for `WeierstrassCurve.Projective.Point.fromAffine` for dot notation. | true |
List.erase_eq_eraseTR | Init.Data.List.Impl | @List.erase = @List.eraseTR | null | 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 | null | 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), (n + 1) • x = n • x + x)
AddMonoid.nsmul_succ._autoParam | null | false |
Lean.Grind.instCommRingInt64._proof_3 | Init.GrindInstances.Ring.SInt | ∀ (i : ℤ) (x : Int64), -i • x = -(i • x) | null | 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₂)) | null | 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 | null | true |
Aesop.UnorderedArraySet.empty | Aesop.Util.UnorderedArraySet | {α : Type u_1} → [inst : BEq α] → Aesop.UnorderedArraySet α | O(1) | true |
_private.Lean.Elab.DeclNameGen.0.Lean.Elab.Command.NameGen.visitNamespace._sunfold | Lean.Elab.DeclNameGen | Lean.Name → Lean.Elab.Command.NameGen.MkNameM✝ Unit | null | false |
CategoryTheory.SimplicialObject.Split.evalN | Mathlib.AlgebraicTopology.SimplicialObject.Split | (C : Type u_1) →
[inst : CategoryTheory.Category.{v_1, u_1} C] → ℕ → CategoryTheory.Functor (CategoryTheory.SimplicialObject.Split C) C | The functor `SimplicialObject.Split C ⥤ C` which sends a simplicial object equipped
with a splitting to its nondegenerate `n`-simplices. | true |
Std.Iter.foldl_toList._cbv_eval_1 | Init.Data.Iterators.Lemmas.Consumers.Loop | ∀ {α β : Type w} {γ : Type x} [inst : Std.Iterator α Id β] [Std.Iterators.Finite α Id]
[inst_2 : Std.IteratorLoop α Id Id] [Std.LawfulIteratorLoop α Id Id] {f : γ → β → γ} {init : γ} {it : Std.Iter β},
Std.Iter.fold f init it = List.foldl f init it.toList | null | false |
Nat.Primrec | Mathlib.Computability.Primrec.Basic | (ℕ → ℕ) → Prop | The primitive recursive functions `ℕ → ℕ`. | 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 | null | 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 | null | 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) | null | 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] | null | true |
Lean.Parser.ParserExtension.instInhabitedEntry.default | Lean.Parser.Extension | Lean.Parser.ParserExtension.Entry | null | true |
le_bot_iff._simp_1 | Mathlib.Order.BoundedOrder.Basic | ∀ {α : Type u} [inst : PartialOrder α] [inst_1 : OrderBot α] {a : α}, (a ≤ ⊥) = (a = ⊥) | null | 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) | null | 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) | Given two code blocks `c₁` and `c₂`, make sure they have the same set of updated variables.
Let `ws` the union of the updated variables in `c₁‵ and ‵c₂`.
We use `extendUpdatedVars c₁ ws` and `extendUpdatedVars c₂ ws`
| 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 | null | 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)
(CategoryTheory.NatIso.ofComponents (fun x => CategoryTheory.yonedaEquiv.toIso) ⋯).hom =
CategoryTheory.CategoryStruct.comp
... | null | 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)] (r s : 𝕜) (x : PreLp E), (r + s) • x = r • x + s • x | null | 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 | null | false |
Lean.Elab.Tactic.evalIntro | Lean.Elab.Tactic.BuiltinTactic | Lean.Elab.Tactic.Tactic | null | true |
SSet.StrictSegal._sizeOf_1 | Mathlib.AlgebraicTopology.SimplicialSet.StrictSegal | {X : SSet} → X.StrictSegal → ℕ | null | 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) | null | false |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.