name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Combinatorics.Additive.VerySmallDoubling.0.Finset.card_mul_finset_lt_two._simp_1_5 | Mathlib.Combinatorics.Additive.VerySmallDoubling | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
IsFractional.map | Mathlib.RingTheory.FractionalIdeal.Operations | ∀ {R : Type u_1} [inst : CommRing R] {S : Submonoid R} {P : Type u_2} [inst_1 : CommRing P] [inst_2 : Algebra R P]
{P' : Type u_3} [inst_3 : CommRing P'] [inst_4 : Algebra R P'] (g : P →ₐ[R] P') {I : Submodule R P},
IsFractional S I → IsFractional S (Submodule.map g.toLinearMap I) | null | true |
_private.Lean.Meta.HaveTelescope.0.Lean.Meta.simpHaveTelescopeAux._sparseCasesOn_11 | Lean.Meta.HaveTelescope | {motive : Lean.Expr → Sort u} →
(t : Lean.Expr) →
((declName : Lean.Name) → (us : List Lean.Level) → motive (Lean.Expr.const declName us)) →
(Nat.hasNotBit 16 t.ctorIdx → motive t) → motive t | null | false |
Nat.Partition.ofComposition_parts | Mathlib.Combinatorics.Enumerative.Partition.Basic | ∀ (n : ℕ) (c : Composition n), (Nat.Partition.ofComposition n c).parts = ↑c.blocks | null | true |
_private.Std.Http.Protocol.H1.0.Std.Http.Protocol.H1.Machine.processNeedHeader.match_1 | Std.Http.Protocol.H1 | (motive : Option (Option (String × String)) → Sort u_1) →
(result : Option (Option (String × String))) →
((name value : String) → motive (some (some (name, value)))) →
(Unit → motive (some none)) → (Unit → motive none) → motive result | null | false |
NNReal.sqrt_mul_le_half_add | Mathlib.Analysis.SpecialFunctions.ArithmeticGeometricMean | ∀ (x y : NNReal), NNReal.sqrt (x * y) ≤ (x + y) / 2 | The AM–GM inequality for two `NNReal`s, with means in canonical form. | true |
Set.mul_iUnion | Mathlib.Algebra.Group.Pointwise.Set.Lattice | ∀ {α : Type u_1} {ι : Sort u_3} [inst : Mul α] (s : Set α) (t : ι → Set α), s * ⋃ i, t i = ⋃ i, s * t i | null | true |
CategoryTheory.Abelian.SpectralObject.spectralSequencePageSc'Iso._auto_1 | Mathlib.Algebra.Homology.SpectralObject.SpectralSequence | Lean.Syntax | null | false |
Lean.Meta.InstanceEntry.ctorIdx | Lean.Meta.Instances | Lean.Meta.InstanceEntry → ℕ | null | false |
FundamentalGroupoid.equiv_apply | Mathlib.AlgebraicTopology.FundamentalGroupoid.Basic | ∀ (X : Type u_3) (x : FundamentalGroupoid X), (FundamentalGroupoid.equiv X) x = x.as | null | true |
Lean.Grind.Field.noNatZeroDivisors.ofIsCharPZero | Init.Grind.Ring.Field | ∀ {α : Type u_1} [inst : Lean.Grind.Field α] [Lean.Grind.IsCharP α 0], Lean.Grind.NoNatZeroDivisors α | null | true |
Std.DTreeMap.Internal.Impl.minKey_insertIfNew | Std.Data.DTreeMap.Internal.Lemmas | ∀ {α : Type u} {β : α → Type v} {instOrd : Ord α} {t : Std.DTreeMap.Internal.Impl α β} [inst : Std.TransOrd α]
(h : t.WF) {k : α} {v : β k},
(Std.DTreeMap.Internal.Impl.insertIfNew k v t ⋯).impl.minKey ⋯ =
t.minKey?.elim k fun k' => if compare k k' = Ordering.lt then k else k' | null | true |
CategoryTheory.Limits.biprod_isZero_iff._simp_1 | Mathlib.CategoryTheory.Limits.Shapes.BinaryBiproducts | ∀ {C : Type uC} [inst : CategoryTheory.Category.{uC', uC} C] [inst_1 : CategoryTheory.Limits.HasZeroMorphisms C]
(A B : C) [inst_2 : CategoryTheory.Limits.HasBinaryBiproduct A B],
CategoryTheory.Limits.IsZero (A ⊞ B) = (CategoryTheory.Limits.IsZero A ∧ CategoryTheory.Limits.IsZero B) | null | false |
CategoryTheory.bifunctorComp₁₂Functor_obj | Mathlib.CategoryTheory.Functor.Trifunctor | ∀ {C₁ : Type u_1} {C₂ : Type u_2} {C₃ : Type u_3} {C₄ : Type u_4} {C₁₂ : Type u_5}
[inst : CategoryTheory.Category.{v_1, u_1} C₁] [inst_1 : CategoryTheory.Category.{v_2, u_2} C₂]
[inst_2 : CategoryTheory.Category.{v_3, u_3} C₃] [inst_3 : CategoryTheory.Category.{v_4, u_4} C₄]
[inst_4 : CategoryTheory.Category.{v_... | null | true |
ENNReal.iInf_coe_eq_top | Mathlib.Basic.ENNReal.Basic | ∀ {ι : Sort u_2} {f : ι → NNReal}, ⨅ i, ↑(f i) = ⊤ ↔ IsEmpty ι | null | true |
_private.Mathlib.Topology.ContinuousOn.0.ContinuousOn.iterate.match_1_1 | Mathlib.Topology.ContinuousOn | ∀ (motive : ℕ → Prop) (x : ℕ), (∀ (_ : Unit), motive 0) → (∀ (n : ℕ), motive n.succ) → motive x | null | false |
MeasureTheory.measureReal_union' | Mathlib.MeasureTheory.Measure.Real | ∀ {α : Type u_1} {x : MeasurableSpace α} {μ : MeasureTheory.Measure α} {s₁ s₂ : Set α},
Disjoint s₁ s₂ →
MeasurableSet s₁ →
autoParam (μ s₁ ≠ ⊤) MeasureTheory.measureReal_union'._auto_1 →
autoParam (μ s₂ ≠ ⊤) MeasureTheory.measureReal_union'._auto_3 → μ.real (s₁ ∪ s₂) = μ.real s₁ + μ.real s₂ | null | true |
_private.Mathlib.Algebra.Polynomial.CoeffList.0.Polynomial.ofCoeffList.match_1.eq_2 | Mathlib.Algebra.Polynomial.CoeffList | ∀ {R : Type u_1} (motive : List R → Sort u_2) (c : R) (p : List R) (h_1 : Unit → motive [])
(h_2 : (c : R) → (p : List R) → motive (c :: p)),
(match c :: p with
| [] => h_1 ()
| c :: p => h_2 c p) =
h_2 c p | null | true |
Matrix.diag_list_sum | Mathlib.Data.Matrix.Basic | ∀ {n : Type u_3} {α : Type u_8} [inst : AddMonoid α] (l : List (Matrix n n α)),
l.sum.diag = (List.map Matrix.diag l).sum | null | true |
_private.Init.Data.Nat.Basic.0.Nat.lt_trichotomy.match_1_3 | Init.Data.Nat.Basic | ∀ (a b : ℕ) (motive : a < b ∨ a ≥ b → Prop) (x : a < b ∨ a ≥ b),
(∀ (h : a < b), motive ⋯) → (∀ (h : a ≥ b), motive ⋯) → motive x | null | false |
SetLike.instSubtypeSet | Mathlib.Basic.SetLike.Basic | {X : Type u_3} → {p : Set X → Prop} → SetLike { s // p s } X | membership is inherited from `Set X` | true |
Std.IterM.anyM_filterMapM | Init.Data.Iterators.Lemmas.Combinators.Monadic.FilterMap | ∀ {α β β' : Type w} {m : Type w → Type w'} {n : Type w → Type w''} [inst : Std.Iterator α m β]
[Std.Iterators.Finite α m] [inst_2 : MonadLiftT m n] [inst_3 : Monad m] [LawfulMonad m] [inst_5 : Monad n]
[inst_6 : MonadAttach n] [LawfulMonad n] [WeaklyLawfulMonadAttach n] {it : Std.IterM m β} {f : β → n (Option β')}
... | null | true |
Std.Do.SPred.Notation.unexpandIff | Std.Do.SPred.Notation | Lean.PrettyPrinter.Unexpander | Unexpander that reconstructs `spred(... ↔ ...)⌝` syntax from applications of `SPred.iff`, lifting
nested applications of `spred(...)` from the arguments.
| true |
_private.Init.Data.String.Basic.0.String.Pos.Raw.isValid_copy_iff._simp_1_6 | Init.Data.String.Basic | ∀ {s : String} {l r : s.Pos}, (l ≤ r) = (l.offset ≤ r.offset) | null | false |
ImportGraph.Widget.CollapsibleProps.body | ImportGraph.Widget.Collapsible | ImportGraph.Widget.CollapsibleProps → Lean.Server.WithRpcRef Lean.MessageData | The hideable body revealed when the dropdown is expanded. | true |
MonoidAlgebra.coeff_zero | Mathlib.Algebra.MonoidAlgebra.Defs | ∀ {R : Type u_1} {M : Type u_4} [inst : Semiring R], MonoidAlgebra.coeff 0 = 0 | null | true |
CategoryTheory.Subgroupoid.Map.Arrows | Mathlib.CategoryTheory.Groupoid.Subgroupoid | {C : Type u} →
[inst : CategoryTheory.Groupoid C] →
{D : Type u_1} →
[inst_1 : CategoryTheory.Groupoid D] →
(φ : CategoryTheory.Functor C D) →
Function.Injective φ.obj → CategoryTheory.Subgroupoid C → (c d : D) → (c ⟶ d) → Prop | The family of arrows of the image of a subgroupoid under a functor injective on objects | true |
Std.instDecidableEqRic.decEq | Init.Data.Range.Polymorphic.PRange | {α : Type u_1} → [DecidableEq α] → (x x_1 : Std.Ric α) → Decidable (x = x_1) | null | true |
_private.Batteries.Data.Fin.Coding.0.Fin.encodeProd.match_1.eq_1 | Batteries.Data.Fin.Coding | ∀ {m n : ℕ} (motive : Fin m × Fin n → Sort u_1) (i : Fin m) (j : Fin n)
(h_1 : (i : Fin m) → (j : Fin n) → motive (i, j)),
(match (i, j) with
| (i, j) => h_1 i j) =
h_1 i j | null | true |
Nat.minSqFacAux._unary | Mathlib.Data.Nat.Squarefree | (_ : ℕ) ×' ℕ → Option ℕ | Assuming that `n` has no factors less than `k`, returns the smallest prime `p` such that
`p^2 ∣ n`. | false |
ProbabilityTheory.Kernel.measure_eq_zero_or_one_of_indepSet_self' | Mathlib.Probability.Independence.ZeroOne | ∀ {α : Type u_1} {Ω : Type u_2} {_mα : MeasurableSpace α} {m0 : MeasurableSpace Ω} {κ : ProbabilityTheory.Kernel α Ω}
{μα : MeasureTheory.Measure α},
(∀ᵐ (a : α) ∂μα, MeasureTheory.IsFiniteMeasure (κ a)) →
∀ {t : Set Ω}, ProbabilityTheory.Kernel.IndepSet t t κ μα → ∀ᵐ (a : α) ∂μα, (κ a) t = 0 ∨ (κ a) t = 1 | null | true |
gc_coinduced_induced | Mathlib.Topology.Order | ∀ {α : Type u_1} {β : Type u_2} (f : α → β),
GaloisConnection (TopologicalSpace.coinduced f) (TopologicalSpace.induced f) | null | true |
Manifold.IsSubmersionAtOfComplement.instNormedSpaceSmallComplement._proof_1 | Mathlib.Geometry.Manifold.Submersion | ∀ {𝕜 : Type u_2} {E'' : Type u_3} {F : Type u_4} {H : Type u_5} {G : Type u_6} {E : Type u_1}
[inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E] [inst_2 : NormedSpace 𝕜 E]
[inst_3 : NormedAddCommGroup E''] [inst_4 : NormedSpace 𝕜 E''] [inst_5 : NormedAddCommGroup F]
[inst_6 : NormedSpace 𝕜 F]... | null | false |
Ideal.instAddCommGroupCotangent._proof_15 | Mathlib.RingTheory.Ideal.Cotangent | ∀ {R : Type u_1} [inst : CommRing R] (I : Ideal R),
autoParam (∀ (a : I.Cotangent), 0 • a = 0) SubNegMonoid.zsmul_zero'._autoParam | null | false |
_private.Init.Data.UInt.Bitwise.0.UInt8.shiftLeft_zero._simp_1_1 | Init.Data.UInt.Bitwise | ∀ {a b : UInt8}, (a = b) = (a.toBitVec = b.toBitVec) | null | false |
MeromorphicOn.divisor_natCast | Mathlib.Analysis.Meromorphic.Divisor | ∀ {𝕜 : Type u_1} [inst : NontriviallyNormedField 𝕜] {U : Set 𝕜} (n : ℕ), MeromorphicOn.divisor (↑n) U = 0 | The divisor of a constant function is `0`.
| true |
CyclotomicField.instIsScalarTower._proof_1 | Mathlib.NumberTheory.Cyclotomic.Basic | ∀ (n : ℕ) (A : Type u_1) (K : Type u_2) [inst : CommRing A] [inst_1 : Field K] [inst_2 : Algebra A K],
IsScalarTower A K (CyclotomicField n K) | null | false |
Subalgebra.op_iSup | Mathlib.Algebra.Algebra.Subalgebra.MulOpposite | ∀ {ι : Sort u_1} {R : Type u_2} {A : Type u_3} [inst : CommSemiring R] [inst_1 : Semiring A] [inst_2 : Algebra R A]
(S : ι → Subalgebra R A), (iSup S).op = ⨆ i, (S i).op | null | true |
Bool.or' | Init.Data.Bool | Bool → Bool → Bool | This used to be a variant of `Bool.or` with better kernel behavior, but `Bool.or` was redefined
to have this kernel-efficient definition.
| true |
_private.Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence.0.CategoryTheory.Abelian.SpectralObject.HasSpectralSequence._proof_14 | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | ∀ {ι : Type u_1} {κ : Type u_2} [inst_2 : Preorder ι] {c : ℤ → ComplexShape κ} {r₀ : ℤ}
(data : CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore ι c r₀) (r r' : ℤ) (pq : κ)
(hrr' : r + -1 * r' + 1 = 0) (hr : r₀ + -1 * r ≤ 0), data.i₀ r' pq ⋯ ≤ data.i₀ r pq ⋯ | null | false |
WithTop.coe_mono | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : Preorder α], Monotone fun a => ↑a | null | true |
Std.Http.instBEqVersion.beq | Std.Http.Data.Version | Std.Http.Version → Std.Http.Version → Bool | null | true |
_private.Lean.Elab.Tactic.Induction.0.Lean.Elab.Tactic.ElimApp.evalAlts.goWithIncremental.match_16 | Lean.Elab.Tactic.Induction | (motive : Lean.Elab.Tactic.ElimApp.Alt → Sort u_1) →
(x : Lean.Elab.Tactic.ElimApp.Alt) →
((altName : Lean.Name) →
(info : Lean.Meta.ElimAltInfo) →
(altMVarId : Lean.MVarId) → motive { name := altName, info := info, mvarId := altMVarId }) →
motive x | null | false |
Lean.Doc.Parser.listItem._unsafe_rec | Lean.DocString.Parser | Lean.Doc.Parser.BlockCtxt → Lean.Parser.ParserFn | null | false |
instLinearOrderEReal._aux_8 | Mathlib.Data.EReal.Basic | DecidableLE EReal | null | false |
Eq.to_iff | Init.Core | ∀ {a b : Prop}, a = b → (a ↔ b) | null | true |
Submodule.restrictScalars_traceDual | Mathlib.RingTheory.DedekindDomain.Different | ∀ {A : Type u_1} {K : Type u_2} {L : Type u} {B : Type u_3} [inst : CommRing A] [inst_1 : Field K] [inst_2 : CommRing B]
[inst_3 : Field L] [inst_4 : Algebra A K] [inst_5 : Algebra B L] [inst_6 : Algebra A B] [inst_7 : Algebra K L]
[inst_8 : Algebra A L] [inst_9 : IsScalarTower A K L] [inst_10 : IsScalarTower A B L... | null | true |
Int16.and_assoc | Init.Data.SInt.Bitwise | ∀ (a b c : Int16), a &&& b &&& c = a &&& (b &&& c) | null | true |
Finset.indicator_biUnion_apply | Mathlib.Algebra.BigOperators.Group.Finset.Indicator | ∀ {ι : Type u_1} {κ : Type u_2} {β : Type u_4} [inst : AddCommMonoid β] (s : Finset ι) (t : ι → Set κ) {f : κ → β},
(↑s).PairwiseDisjoint t → ∀ (x : κ), (⋃ i ∈ s, t i).indicator f x = ∑ i ∈ s, (t i).indicator f x | null | true |
CentroidHom.copy | Mathlib.Algebra.Ring.CentroidHom | {α : Type u_5} → [inst : NonUnitalNonAssocSemiring α] → (f : CentroidHom α) → (f' : α → α) → f' = ⇑f → CentroidHom α | Copy of a `CentroidHom` with a new `toFun` equal to the old one. Useful to fix
definitional equalities. | true |
Lean.PrettyPrinter.Parenthesizer.checkLineEq.parenthesizer | Lean.PrettyPrinter.Parenthesizer | Lean.PrettyPrinter.Parenthesizer | null | true |
Matrix.SpecialLinearGroup.fin_two_exists_eq_mk_of_apply_zero_one_eq_zero._proof_1 | Mathlib.LinearAlgebra.Matrix.SpecialLinearGroup | ∀ {R : Type u_1} [inst : Field R] (a b : R), a ≠ 0 → !![a, b; 0, a⁻¹].det = 1 | null | false |
_private.Mathlib.MeasureTheory.Measure.Support.0.MeasureTheory.Measure.support_eq_forall_isOpen._simp_1_1 | Mathlib.MeasureTheory.Measure.Support | ∀ {α : Type u} {a b : Set α}, (a = b) = ∀ (x : α), x ∈ a ↔ x ∈ b | null | false |
PadicInt.subring._proof_3 | Mathlib.NumberTheory.Padics.PadicIntegers | ∀ (p : ℕ) [hp : Fact (Nat.Prime p)] {a b : ℚ_[p]}, a ∈ {x | ‖x‖ ≤ 1} → b ∈ {x | ‖x‖ ≤ 1} → ‖a‖ * ‖b‖ ≤ 1 | null | false |
normalizedGCDMonoidOfExistsLCM._proof_2 | Mathlib.Algebra.GCDMonoid.Basic | ∀ {α : Type u_1} [inst : CommMonoidWithZero α] [inst_1 : NormalizationMonoid α]
(h : ∀ (a b : α), ∃ c, ∀ (d : α), a ∣ d ∧ b ∣ d ↔ c ∣ d) (a b : α), b ∣ normalize (Classical.choose ⋯) | null | false |
Lean.Option._sizeOf_inst | Lean.Data.Options | (α : Type) → [SizeOf α] → SizeOf (Lean.Option α) | null | false |
Ordinal.veblen_eq_of_lt_invVeblen₁ | Mathlib.SetTheory.Ordinal.Veblen | ∀ {o x : Ordinal.{u}}, o < x.invVeblen₁ → Ordinal.veblen o x = x | null | true |
MeasureTheory.Measure.haarScalarFactor.eq_1 | Mathlib.MeasureTheory.Measure.Haar.Unique | ∀ {G : Type u_1} [inst : TopologicalSpace G] [inst_1 : Group G] [inst_2 : IsTopologicalGroup G]
[inst_3 : MeasurableSpace G] [inst_4 : BorelSpace G] (μ' μ : MeasureTheory.Measure G) [inst_5 : μ.IsHaarMeasure]
[inst_6 : MeasureTheory.IsFiniteMeasureOnCompacts μ'] [inst_7 : μ'.IsMulLeftInvariant],
μ'.haarScalarFact... | null | true |
_private.Mathlib.Tactic.Linter.TextBased.0.Mathlib.Linter.TextBased.TextbasedLinter | Mathlib.Tactic.Linter.TextBased | Type | Core logic of a text based linter: given a collection of lines,
return an array of all style errors with (1-based!) line numbers. If possible,
also return the collection of all lines, changed as needed to fix the linter errors.
(Such automatic fixes are only possible for some kinds of `StyleError`s.)
| true |
HasDerivAt.fun_add | Mathlib.Analysis.Calculus.Deriv.Add | ∀ {𝕜 : Type u} [inst : NontriviallyNormedField 𝕜] {F : Type v} [inst_1 : NormedAddCommGroup F]
[inst_2 : NormedSpace 𝕜 F] {f g : 𝕜 → F} {f' g' : F} {x : 𝕜},
HasDerivAt f f' x → HasDerivAt g g' x → HasDerivAt (fun i => f i + g i) (f' + g') x | Eta-expanded form of `HasDerivAt.add` | true |
MonoidAlgebra.mapDomainBialgHom | Mathlib.RingTheory.Bialgebra.MonoidAlgebra | (R : Type u_1) →
{M : Type u_8} →
{N : Type u_9} →
[inst : CommSemiring R] →
[inst_1 : Monoid M] → [inst_2 : Monoid N] → (M →* N) → MonoidAlgebra R M →ₐc[R] MonoidAlgebra R N | If `f : M → N` is a monoid hom, then `MonoidAlgebra.mapDomain f` is a bialgebra hom between
their monoid algebras. | true |
PiTensorProduct.mapL_apply | Mathlib.Analysis.Normed.Module.PiTensorProduct.ProjectiveSeminorm | ∀ {ι : Type u_1} [inst : Fintype ι] {𝕜 : Type u_2} {E : ι → Type u_3} [inst_1 : (i : ι) → SeminormedAddCommGroup (E i)]
[inst_2 : NontriviallyNormedField 𝕜] [inst_3 : (i : ι) → NormedSpace 𝕜 (E i)] {E' : ι → Type u_5}
[inst_4 : (i : ι) → SeminormedAddCommGroup (E' i)] [inst_5 : (i : ι) → NormedSpace 𝕜 (E' i)]
... | null | true |
_private.Mathlib.Topology.Inseparable.0.inseparable_iff_forall_isClosed._simp_1_4 | Mathlib.Topology.Inseparable | ∀ {a b : Prop}, ((a → b) ∧ (b → a)) = (a ↔ b) | null | false |
precMin1 | Init.Notation | Lean.ParserDescr | `(min+1)` (we can only write `min+1` after `Meta.lean`) | true |
Homeomorph.toMeasurableEquiv.congr_simp | Mathlib.MeasureTheory.Function.LocallyIntegrable | ∀ {γ : Type u_3} {γ₂ : Type u_4} [inst : TopologicalSpace γ] [inst_1 : MeasurableSpace γ] [inst_2 : BorelSpace γ]
[inst_3 : TopologicalSpace γ₂] [inst_4 : MeasurableSpace γ₂] [inst_5 : BorelSpace γ₂] (h h_1 : γ ≃ₜ γ₂),
h = h_1 → h.toMeasurableEquiv = h_1.toMeasurableEquiv | null | true |
Circle.instMetricSpace._proof_5 | Mathlib.Analysis.Complex.Circle | ∀ (x y z : Circle), dist x z ≤ dist x y + dist y z | null | false |
Set.mem_list_prod | Mathlib.Algebra.Group.Pointwise.Set.ListOfFn | ∀ {α : Type u_1} [inst : Monoid α] {l : List (Set α)} {a : α},
a ∈ l.prod ↔ ∃ l', (List.map (fun x => ↑x.snd) l').prod = a ∧ List.map Sigma.fst l' = l | null | true |
PartialEquiv.refl_source | Mathlib.Logic.Equiv.PartialEquiv | ∀ {α : Type u_1}, (PartialEquiv.refl α).source = Set.univ | null | true |
_private.Init.Data.List.ToArray.0.List.mapA.match_1.eq_2 | Init.Data.List.ToArray | ∀ {α : Type u_1} (motive : List α → Sort u_2) (a : α) (as : List α) (h_1 : Unit → motive [])
(h_2 : (a : α) → (as : List α) → motive (a :: as)),
(match a :: as with
| [] => h_1 ()
| a :: as => h_2 a as) =
h_2 a as | null | true |
Std.ExtHashMap.mem_of_mem_insertIfNew' | Std.Data.ExtHashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.ExtHashMap α β} [inst : EquivBEq α]
[inst_1 : LawfulHashable α] {k a : α} {v : β}, a ∈ m.insertIfNew k v → ¬((k == a) = true ∧ k ∉ m) → a ∈ m | This is a restatement of `mem_of_mem_insertIfNew` that is written to exactly match the proof obligation
in the statement of `getElem_insertIfNew`. | true |
Sum.Lex.inlLatticeHom._proof_2 | Mathlib.Order.Sum.Lattice | ∀ {α : Type u_1} {β : Type u_2} [inst : Lattice α] (x x_1 : α), Sum.inlₗ (x ⊓ x_1) = Sum.inlₗ (x ⊓ x_1) | null | false |
DivInvOneMonoid.rec | Mathlib.Algebra.Group.DivInvMonoid | {G : Type u_2} →
{motive : DivInvOneMonoid G → Sort u} →
([toDivInvMonoid : DivInvMonoid G] →
(inv_one : 1⁻¹ = 1) → motive { toDivInvMonoid := toDivInvMonoid, inv_one := inv_one }) →
(t : DivInvOneMonoid G) → motive t | null | false |
CategoryTheory.GrothendieckTopology.instInhabited | Mathlib.CategoryTheory.Sites.Grothendieck | {C : Type u} → [inst : CategoryTheory.Category.{v, u} C] → Inhabited (CategoryTheory.GrothendieckTopology C) | null | true |
OpenPartialHomeomorph.coe_toPartialEquiv_symm | Mathlib.Topology.OpenPartialHomeomorph.Defs | ∀ {X : Type u_1} {Y : Type u_3} [inst : TopologicalSpace X] [inst_1 : TopologicalSpace Y]
(e : OpenPartialHomeomorph X Y), ↑e.symm = ↑e.symm | null | true |
MeasureTheory.Measure.Regular.toIsFiniteMeasureOnCompacts | Mathlib.MeasureTheory.Measure.Regular | ∀ {α : Type u_1} {inst : MeasurableSpace α} {inst_1 : TopologicalSpace α} {μ : MeasureTheory.Measure α}
[self : μ.Regular], MeasureTheory.IsFiniteMeasureOnCompacts μ | null | true |
_private.Mathlib.Tactic.Attr.Register.0.initFn._@.Mathlib.Tactic.Attr.Register.1988518680._hygCtx._hyg.5 | Mathlib.Tactic.Attr.Register | IO Lean.Meta.SimpExtension | null | false |
Lean.Elab.UserWidgetInfo.mk.inj | Lean.Elab.InfoTree.Types | ∀ {toWidgetInstance : Lean.Widget.WidgetInstance} {stx : Lean.Syntax} {toWidgetInstance_1 : Lean.Widget.WidgetInstance}
{stx_1 : Lean.Syntax},
{ toWidgetInstance := toWidgetInstance, stx := stx } = { toWidgetInstance := toWidgetInstance_1, stx := stx_1 } →
toWidgetInstance = toWidgetInstance_1 ∧ stx = stx_1 | null | true |
DividedPowers.ext | Mathlib.RingTheory.DividedPowers.Basic | ∀ {A : Type u_1} [inst : CommSemiring A] {I : Ideal A} (hI hI' : DividedPowers I),
(∀ (n : ℕ) {x : A}, x ∈ I → hI.dpow n x = hI'.dpow n x) → hI = hI' | null | true |
_private.Mathlib.Tactic.LinearCombination.0.Mathlib.Tactic.LinearCombination.expandLinearCombo.match_1 | Mathlib.Tactic.LinearCombination | (motive : Option (Mathlib.Ineq × Lean.Expr × Lean.Expr × Lean.Expr) → Sort u_1) →
(__do_lift : Option (Mathlib.Ineq × Lean.Expr × Lean.Expr × Lean.Expr)) →
((rel : Mathlib.Ineq) → (snd : Lean.Expr × Lean.Expr × Lean.Expr) → motive (some (rel, snd))) →
(Unit → motive none) → motive __do_lift | null | false |
IsScalarTower.toAlgHom | Mathlib.Algebra.Algebra.Hom | (R : Type u_1) →
(S : Type u_2) →
(A : Type u_3) →
[inst : CommSemiring R] →
[inst_1 : CommSemiring S] →
[inst_2 : Semiring A] →
[inst_3 : Algebra R S] → [inst_4 : Algebra S A] → [inst_5 : Algebra R A] → [IsScalarTower R S A] → S →ₐ[R] A | In a tower, the canonical map from the middle element to the top element is an
algebra homomorphism over the bottom element. | true |
_private.Mathlib.Data.Finset.Max.0.Finset.max_of_mem.match_1_1 | Mathlib.Data.Finset.Max | ∀ {α : Type u_1} [inst : LinearOrder α] {s : Finset α} {a : α} (motive : (∃ b, s.sup WithBot.some = ↑b ∧ a ≤ b) → Prop)
(x : ∃ b, s.sup WithBot.some = ↑b ∧ a ≤ b),
(∀ (b : α) (h : s.sup WithBot.some = ↑b) (right : a ≤ b), motive ⋯) → motive x | null | false |
instPredOrderShrink | Mathlib.Order.Shrink | {α : Type u_1} → [inst : Small.{u, u_1} α] → [inst_1 : Preorder α] → [PredOrder α] → PredOrder (Shrink.{u, u_1} α) | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.0._regBuiltin.Int8.reduceLT.declare_44._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt.2990342300._hygCtx._hyg.180 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.SInt | IO Unit | null | false |
exists_rat_of_not_irrational | Mathlib.NumberTheory.Real.Irrational | ∀ {x : ℝ}, ¬Irrational x → ∃ q, x = ↑q | null | true |
AlgebraicGeometry.pullbackRestrictIsoRestrict_hom_ι_assoc | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) {Z : AlgebraicGeometry.Scheme} (h : X ⟶ Z),
CategoryTheory.CategoryStruct.comp (AlgebraicGeometry.pullbackRestrictIsoRestrict f U).hom
(CategoryTheory.CategoryStruct.comp ((TopologicalSpace.Opens.map f.base).obj U).ι h) =
CategoryTheory.CategorySt... | null | true |
Lean.Meta.Grind.Arith.CommRing.Ring.intCastFn?._default | Lean.Meta.Tactic.Grind.Arith.CommRing.Types | Option Lean.Expr | null | false |
NonUnitalStarSubalgebra.instIsSemitopologicalSemiring | Mathlib.Topology.Algebra.NonUnitalStarAlgebra | ∀ {R : Type u_1} {A : Type u_2} [inst : CommSemiring R] [inst_1 : TopologicalSpace A] [inst_2 : Star A]
[inst_3 : NonUnitalSemiring A] [inst_4 : Module R A] [IsSemitopologicalSemiring A] (s : NonUnitalStarSubalgebra R A),
IsSemitopologicalSemiring ↥s | null | true |
_private.Mathlib.Algebra.QuadraticAlgebra.Defs.0.QuadraticAlgebra.instNonUnitalNonAssocSemiring._abel_5 | Mathlib.Algebra.QuadraticAlgebra.Defs | ∀ {R : Type u_1} {a b : R} [inst : NonUnitalNonAssocSemiring R] (x x_1 x_2 : QuadraticAlgebra R a b),
x.re * x_2.im + x_1.re * x_2.im + (x.im * x_2.re + x_1.im * x_2.re) + (b * x.im * x_2.im + b * x_1.im * x_2.im) =
x.re * x_2.im + x.im * x_2.re + b * x.im * x_2.im + (x_1.re * x_2.im + x_1.im * x_2.re + b * x_1.i... | null | false |
_private.Lean.Compiler.IR.Basic.0.Lean.IR.FnBody.alphaEqv._sparseCasesOn_4 | Lean.Compiler.IR.Basic | {motive_1 : Lean.IR.Alt → Sort u} →
(t : Lean.IR.Alt) →
((b : Lean.IR.FnBody) → motive_1 (Lean.IR.Alt.default b)) → (Nat.hasNotBit 2 t.ctorIdx → motive_1 t) → motive_1 t | null | false |
Mathlib.Tactic.LibrarySearch.«_aux_Mathlib_Tactic_Observe___macroRules_Mathlib_Tactic_LibrarySearch_tacticObserve?__:_Using__,,_1» | Mathlib.Tactic.Observe | Lean.Macro | null | false |
ProbabilityTheory.iIndepFun.indepFun_mul_right₀ | Mathlib.Probability.Independence.Basic | ∀ {Ω : Type u_1} {ι : Type u_2} {_mΩ : MeasurableSpace Ω} {μ : MeasureTheory.Measure Ω} {β : Type u_10}
{m : MeasurableSpace β} [inst : Mul β] [MeasurableMul₂ β] {f : ι → Ω → β},
ProbabilityTheory.iIndepFun f μ →
(∀ (i : ι), AEMeasurable (f i) μ) → ∀ (i j k : ι), i ≠ j → i ≠ k → ProbabilityTheory.IndepFun (f i)... | null | true |
Flag.casesOn | Mathlib.Order.Preorder.Chain | {α : Type u_4} →
[inst : LE α] →
{motive : Flag α → Sort u} →
(t : Flag α) →
((carrier : Set α) →
(Chain' : IsChain (fun x1 x2 => x1 ≤ x2) carrier) →
(max_chain' : ∀ ⦃s : Set α⦄, IsChain (fun x1 x2 => x1 ≤ x2) s → carrier ⊆ s → carrier = s) →
motive { carrie... | null | false |
_private.Mathlib.RingTheory.Polynomial.Basic.0.Polynomial.mem_degreeLE._simp_1_4 | Mathlib.RingTheory.Polynomial.Basic | ∀ {R : Type u_1} {R₂ : Type u_2} {M : Type u_5} {M₂ : Type u_6} [inst : Semiring R] [inst_1 : Semiring R₂]
[inst_2 : AddCommMonoid M] [inst_3 : AddCommMonoid M₂] [inst_4 : Module R M] [inst_5 : Module R₂ M₂] {τ₁₂ : R →+* R₂}
{f : M →ₛₗ[τ₁₂] M₂} {y : M}, (y ∈ f.ker) = (f y = 0) | null | false |
TensorProduct.tensorQuotEquivQuotSMul | Mathlib.LinearAlgebra.TensorProduct.Quotient | {R : Type u_1} →
(M : Type u_2) →
[inst : CommRing R] →
[inst_1 : AddCommGroup M] → [inst_2 : Module R M] → (I : Ideal R) → TensorProduct R M (R ⧸ I) ≃ₗ[R] M ⧸ I • ⊤ | Right tensoring a module with a quotient of the ring is the same as
quotienting that module by the corresponding submodule. | true |
_private.Mathlib.Data.Finset.Union.0.Finset.filter_biUnion._proof_1_1 | Mathlib.Data.Finset.Union | ∀ {α : Type u_2} {β : Type u_1} [inst : DecidableEq β] (s : Finset α) (f : α → Finset β) (p : β → Prop)
[inst_1 : DecidablePred p], Finset.filter p (s.biUnion f) = s.biUnion fun a => Finset.filter p (f a) | null | false |
_private.Mathlib.Data.Nat.Multiplicity.0.Nat.emultiplicity_eq_card_pow_dvd._simp_1_6 | Mathlib.Data.Nat.Multiplicity | ∀ {p q : Prop}, (p ↔ q ∧ p) = (p → q) | null | false |
WithTop.coe_nsmul._simp_1 | Mathlib.Algebra.Order.Monoid.Unbundled.WithTop | ∀ {α : Type u} [inst : AddMonoid α] (a : α) (n : ℕ), n • ↑a = ↑(n • a) | null | false |
SheafOfModules.QuasicoherentData.IsFinitePresentation.mk | Mathlib.Algebra.Category.ModuleCat.Sheaf.Quasicoherent | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {J : CategoryTheory.GrothendieckTopology C}
{R : CategoryTheory.Sheaf J RingCat} [inst_1 : ∀ (X : C), CategoryTheory.HasWeakSheafify (J.over X) AddCommGrpCat]
[inst_2 : ∀ (X : C), (J.over X).WEqualsLocallyBijective AddCommGrpCat] {M : SheafOfModules R}
{... | null | true |
CategoryTheory.Subobject.imageFactorisation._proof_3 | Mathlib.CategoryTheory.Subobject.Basic | ∀ {C : Type u_2} [inst : CategoryTheory.Category.{u_1, u_2} C] {X Y : C} [CategoryTheory.Limits.HasImages C] (f : X ⟶ Y)
(x : CategoryTheory.Subobject X), CategoryTheory.Limits.HasImage (CategoryTheory.CategoryStruct.comp x.arrow f) | null | false |
Finset.disjoint_range_addRightEmbedding | Mathlib.Algebra.Group.Nat.Range | ∀ (a : ℕ) (s : Finset ℕ), Disjoint (Finset.range a) (Finset.map (addRightEmbedding a) s) | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.