name stringlengths 2 347 | module stringlengths 6 90 | type stringlengths 1 5.42M | docString stringlengths 0 11k ⌀ | allowCompletion bool 2
classes |
|---|---|---|---|---|
_private.Mathlib.Algebra.BigOperators.ModEq.0.Int.prod_modEq_single._simp_1_1 | Mathlib.Algebra.BigOperators.ModEq | ∀ (a b : ℤ) (c : ℕ), (a ≡ b [ZMOD ↑c]) = (↑a = ↑b) | null | false |
CategoryTheory.Comma.unopFunctor_map | Mathlib.CategoryTheory.Comma.Basic | ∀ {A : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} A] {B : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} B]
{T : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} T] (L : CategoryTheory.Functor A T)
(R : CategoryTheory.Functor B T) {X Y : CategoryTheory.Comma L.op R.op} (f : X ⟶ Y),
(CategoryTheory.... | null | true |
AddCommMonCat.recOn | Mathlib.Algebra.Category.MonCat.Basic | {motive : AddCommMonCat → Sort u_1} →
(t : AddCommMonCat) →
((carrier : Type u) → [str : AddCommMonoid carrier] → motive { carrier := carrier, str := str }) → motive t | null | false |
Subfield.sInf_toSubring | Mathlib.Algebra.Field.Subfield.Basic | ∀ {K : Type u} [inst : DivisionRing K] (s : Set (Subfield K)), (sInf s).toSubring = ⨅ t ∈ s, t.toSubring | null | true |
WeierstrassCurve.Projective.negDblY_eq' | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} {P : Fin 3 → R},
W'.Equation P →
W'.negDblY P * P 2 ^ 2 =
-(MvPolynomial.eval P) W'.polynomialX *
((MvPolynomial.eval P) W'.polynomialX ^ 2 -
W'.a₁ * (MvPolynomial.eval P) W'.polynomialX * P 2 * (P 1 - W'.neg... | null | true |
himp_iff_imp._simp_1 | Mathlib.Order.Heyting.Basic | ∀ (p q : Prop), p ⇨ q = (p → q) | null | false |
_private.Mathlib.Probability.Distributions.SetBernoulli.0.ProbabilityTheory.setBernoulli_ae_subset._simp_1_2 | Mathlib.Probability.Distributions.SetBernoulli | ∀ {α : Type u_1} {s t : Set α}, (¬s ⊆ t) = ∃ x ∈ s, x ∉ t | null | false |
HasFiniteFPowerSeriesOnBall.rec | Mathlib.Analysis.Analytic.CPolynomialDef | {𝕜 : Type u_1} →
{E : Type u_2} →
{F : Type u_3} →
[inst : NontriviallyNormedField 𝕜] →
[inst_1 : NormedAddCommGroup E] →
[inst_2 : NormedSpace 𝕜 E] →
[inst_3 : NormedAddCommGroup F] →
[inst_4 : NormedSpace 𝕜 F] →
{f : E → F} →
... | null | false |
Set.biUnion_diff_biUnion_eq | Mathlib.Data.Set.Pairwise.Lattice | ∀ {α : Type u_1} {ι : Type u_2} {s t : Set ι} {f : ι → Set α},
(s ∪ t).PairwiseDisjoint f → (⋃ i ∈ s, f i) \ ⋃ i ∈ t, f i = ⋃ i ∈ s \ t, f i | **Alias** of `Set.biUnion_sdiff_biUnion_eq`. | true |
_private.Mathlib.CategoryTheory.Limits.Shapes.Images.0.CategoryTheory.Limits.image.map_id._simp_1_1 | Mathlib.CategoryTheory.Limits.Shapes.Images | ∀ {α : Sort u_1} [Subsingleton α] (x y : α), (x = y) = True | null | false |
_private.Mathlib.Data.Finset.NAry.0.Finset.mem_image₂._simp_1_2 | Mathlib.Data.Finset.NAry | ∀ {a b c : Prop}, ((a ∧ b) ∧ c) = (a ∧ b ∧ c) | null | false |
Mathlib.Tactic.WLOGResult.reductionGoal | Mathlib.Tactic.WLOG | Mathlib.Tactic.WLOGResult → Lean.MVarId | The `reductionGoal` requires showing that the case `h : ¬ P` can be reduced to the case where
`P` holds. It has two additional assumptions in its context:
* `h : ¬ P`: the assumption that `P` does not hold
* `H`: the statement that in the original context `P` suffices to prove the goal.
| true |
LinearMap.instSMulCommClassWithConvId | Mathlib.RingTheory.Coalgebra.Convolution | ∀ {R : Type u_1} {S : Type u_2} {A : Type u_3} {C : Type u_5} [inst : CommSemiring R]
[inst_1 : NonUnitalNonAssocSemiring A] [inst_2 : Module R A] [inst_3 : SMulCommClass R A A]
[inst_4 : IsScalarTower R A A] [inst_5 : AddCommMonoid C] [inst_6 : Module R C] [inst_7 : CoalgebraStruct R C]
[inst_8 : Monoid S] [inst... | null | true |
NumberField.RingOfIntegers.mapAlgEquiv._proof_1 | Mathlib.NumberTheory.NumberField.Basic | ∀ {k : Type u_2} {K : Type u_3} {L : Type u_4} {E : Type u_1} [inst : Field k] [inst_1 : Field K] [inst_2 : Field L]
[inst_3 : Algebra k K] [inst_4 : Algebra k L] [inst_5 : EquivLike E K L] [AlgEquivClass E k K L], AlgHomClass E k K L | null | false |
CStarMatrix.instAddMonoid._proof_3 | Mathlib.Analysis.CStarAlgebra.CStarMatrix | ∀ {m : Type u_1} {n : Type u_2} {A : Type u_3} [inst : AddMonoid A] (a : CStarMatrix m n A), a + 0 = a | null | false |
Std.HashMap.getD_eq_fallback_of_contains_eq_false | Std.Data.HashMap.Lemmas | ∀ {α : Type u} {β : Type v} {x : BEq α} {x_1 : Hashable α} {m : Std.HashMap α β} [EquivBEq α] [LawfulHashable α] {a : α}
{fallback : β}, m.contains a = false → m.getD a fallback = fallback | null | true |
_private.Mathlib.Analysis.InnerProductSpace.Dual.0.InnerProductSpace.toDual._simp_5 | Mathlib.Analysis.InnerProductSpace.Dual | ∀ {M₀ : Type u_1} [inst : MonoidWithZero M₀] {a : M₀} [IsReduced M₀] (n : ℕ), a ≠ 0 → (a ^ n = 0) = False | null | false |
CategoryTheory.Functor.isoWhiskerRight_twice | Mathlib.CategoryTheory.Whiskering | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{E : Type u₃} [inst_2 : CategoryTheory.Category.{v₃, u₃} E] {B : Type u₄}
[inst_3 : CategoryTheory.Category.{v₄, u₄} B] {H K : CategoryTheory.Functor B C} (F : CategoryTheory.Functor C D)
(G : C... | null | true |
ContinuousMap.concat | Mathlib.Topology.ContinuousMap.Interval | {α : Type u_1} →
[inst : LinearOrder α] →
[inst_1 : TopologicalSpace α] →
[OrderTopology α] →
{a b c : α} →
[Fact (a ≤ b)] →
[Fact (b ≤ c)] →
{E : Type u_2} →
[inst_5 : TopologicalSpace E] → C(↑(Set.Icc a b), E) → C(↑(Set.Icc b c), E) → C(↑(Set.Icc... | The concatenation of two continuous maps defined on adjacent intervals. If the values of the
functions on the common bound do not agree, this is defined as an arbitrarily chosen constant
map. See `concatCM` for the corresponding map on the subtype of compatible function pairs. | true |
GaussianInt.abs_natCast_norm | Mathlib.NumberTheory.Zsqrtd.GaussianInt | ∀ (x : GaussianInt), ↑(Zsqrtd.norm x).natAbs = Zsqrtd.norm x | null | true |
instAddGroupObjOppositeOpensCarrierOfPresheafSmoothSheaf._aux_8 | Mathlib.Geometry.Manifold.Sheaf.Smooth | {𝕜 : Type u_2} →
[inst : NontriviallyNormedField 𝕜] →
{EM : Type u_3} →
[inst_1 : NormedAddCommGroup EM] →
[inst_2 : NormedSpace 𝕜 EM] →
{HM : Type u_4} →
[inst_3 : TopologicalSpace HM] →
(IM : ModelWithCorners 𝕜 EM HM) →
{E : Type u_5} →
... | null | false |
StarAlgEquiv.trans_apply | Mathlib.Algebra.Star.StarAlgHom | ∀ {R : Type u_2} {A : Type u_3} {B : Type u_4} {C : Type u_5} [inst : Add A] [inst_1 : Add B] [inst_2 : Mul A]
[inst_3 : Mul B] [inst_4 : SMul R A] [inst_5 : SMul R B] [inst_6 : Star A] [inst_7 : Star B] [inst_8 : Add C]
[inst_9 : Mul C] [inst_10 : SMul R C] [inst_11 : Star C] (e₁ : A ≃⋆ₐ[R] B) (e₂ : B ≃⋆ₐ[R] C) (x... | null | true |
NNRat.instIsScalarTowerRight | Mathlib.Algebra.Ring.Action.Rat | ∀ {R : Type u_1} [inst : DivisionSemiring R], IsScalarTower ℚ≥0 R R | null | true |
Id.instLawfulMonadLiftTOfLawfulMonad | Init.Control.Lawful.MonadLift.Instances | ∀ {m : Type u → Type v} [inst : Monad m] [LawfulMonad m], LawfulMonadLiftT Id m | null | true |
DistribLattice.ctorIdx | Mathlib.Order.Defs.Lattice | {α : Type u_1} → DistribLattice α → ℕ | null | false |
RelIso.instGroup._proof_2 | Mathlib.Algebra.Order.Group.End | ∀ {α : Type u_1} {r : α → α → Prop} (n : ℕ) (x : r ≃r r), x ^ (n + 1) = x ^ n * x | null | false |
Std.Tactic.BVDecide.BVExpr.replicate.injEq | Std.Tactic.BVDecide.Bitblast.BVExpr.Basic | ∀ {w w' : ℕ} (n : ℕ) (expr : Std.Tactic.BVDecide.BVExpr w) (h : w' = w * n) (w_1 n_1 : ℕ)
(expr_1 : Std.Tactic.BVDecide.BVExpr w_1) (h_1 : w' = w_1 * n_1),
(Std.Tactic.BVDecide.BVExpr.replicate n expr h = Std.Tactic.BVDecide.BVExpr.replicate n_1 expr_1 h_1) =
(w = w_1 ∧ n = n_1 ∧ expr ≍ expr_1) | null | true |
Prod.map_iterate | Mathlib.Data.Prod.Basic | ∀ {α : Type u_1} {β : Type u_2} (f : α → α) (g : β → β) (n : ℕ), (Prod.map f g)^[n] = Prod.map f^[n] g^[n] | null | true |
String.Legacy.Iterator.s | Init.Data.String.Iterator | String.Legacy.Iterator → String | The string being iterated over. | true |
WeierstrassCurve.Projective.addXYZ_Z | Mathlib.AlgebraicGeometry.EllipticCurve.Projective.Formula | ∀ {R : Type r} [inst : CommRing R] {W' : WeierstrassCurve.Projective R} (P Q : Fin 3 → R), W'.addXYZ P Q 2 = W'.addZ P Q | null | true |
PseudoMetric.coe_le_coe | Mathlib.Topology.MetricSpace.BundledFun | ∀ {X : Type u_1} {R : Type u_2} [inst : Zero R] [inst_1 : Add R] [inst_2 : LE R] {d d' : PseudoMetric X R},
⇑d ≤ ⇑d' ↔ d ≤ d' | null | true |
_private.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.0.Char.reduceBNe._regBuiltin.Char.reduceBNe.declare_1._@.Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char.83380857._hygCtx._hyg.29 | Lean.Meta.Tactic.Simp.BuiltinSimprocs.Char | IO Unit | null | false |
AlgebraicGeometry.morphismRestrictStalkMap._proof_2 | Mathlib.AlgebraicGeometry.Restrict | ∀ {X Y : AlgebraicGeometry.Scheme} (f : X ⟶ Y) (U : Y.Opens) (x : ↥↑((TopologicalSpace.Opens.map f.base).obj U)),
Inseparable (↑((f ∣_ U) x)) (f ↑x) | null | false |
CategoryTheory.Functor.isSplitEpi_iff._simp_2 | Mathlib.CategoryTheory.Functor.EpiMono | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
(F : CategoryTheory.Functor C D) {X Y : C} (f : X ⟶ Y) [F.Full] [F.Faithful],
CategoryTheory.IsSplitEpi (F.map f) = CategoryTheory.IsSplitEpi f | null | false |
CategoryTheory.NatTrans.naturality | Mathlib.CategoryTheory.NatTrans | ∀ {C : Type u₁} [inst : CategoryTheory.Category.{v₁, u₁} C] {D : Type u₂} [inst_1 : CategoryTheory.Category.{v₂, u₂} D]
{F G : CategoryTheory.Functor C D} (self : CategoryTheory.NatTrans F G) ⦃X Y : C⦄ (f : X ⟶ Y),
CategoryTheory.CategoryStruct.comp (F.map f) (self.app Y) = CategoryTheory.CategoryStruct.comp (self.... | The naturality square for a given morphism. | true |
_private.Mathlib.Data.Finset.Union.0.Finset.bind_toFinset._simp_1_2 | Mathlib.Data.Finset.Union | ∀ {α : Type u_1} {β : Type v} {b : β} {s : Multiset α} {f : α → Multiset β}, (b ∈ s.bind f) = ∃ a ∈ s, b ∈ f a | null | false |
FreeSimplexQuiver.homRel.recOn | Mathlib.AlgebraicTopology.SimplexCategory.GeneratorsRelations.Basic | ∀ {motive : ⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ → (a a_1 : X ⟶ Y) → FreeSimplexQuiver.homRel a a_1 → Prop}
⦃X Y : CategoryTheory.Paths FreeSimplexQuiver⦄ {a a_1 : X ⟶ Y} (t : FreeSimplexQuiver.homRel a a_1),
(∀ {n : ℕ} {i j : Fin (n + 2)} (H : i ≤ j),
motive
(CategoryTheory.CategoryStruct.c... | null | false |
conditionallyCompleteLatticeOfsInf.eq_1 | Mathlib.Order.ConditionallyCompleteLattice.Defs | ∀ (α : Type u_2) [H1 : PartialOrder α] [H2 : InfSet α] (bddBelow_pair : ∀ (a b : α), BddAbove {a, b})
(bddAbove_pair : ∀ (a b : α), BddBelow {a, b})
(isLUB_sSup : ∀ (s : Set α), BddBelow s → s.Nonempty → IsGLB s (sInf s)),
conditionallyCompleteLatticeOfsInf α bddBelow_pair bddAbove_pair isLUB_sSup =
{ toLatti... | null | true |
GrpCat.toAddGrp._proof_1 | Mathlib.Algebra.Category.Grp.EquivalenceGroupAddGroup | ∀ (X : GrpCat),
AddGrpCat.ofHom (MonoidHom.toAdditive (GrpCat.Hom.hom (CategoryTheory.CategoryStruct.id X))) =
CategoryTheory.CategoryStruct.id ↧(Additive ↑X) | null | false |
CategoryTheory.Abelian.SpectralObject.coreE₂CohomologicalFin | Mathlib.Algebra.Homology.SpectralObject.HasSpectralSequence | (l : ℕ) →
CategoryTheory.Abelian.SpectralObject.SpectralSequenceDataCore (Fin (l + 1))
(fun r => ComplexShape.spectralSequenceFin l (r, 1 - r)) 2 | The data which allows to construct an `E₂`-cohomological spectral sequence
indexed by `ℤ × Fin l` from a spectral object indexed by `Fin (l + 1)`. | true |
WithBot.unbot_mono | Mathlib.Order.WithBot | ∀ {α : Type u_1} [inst : LE α] {x y : WithBot α} (hx : x ≠ ⊥) (hy : y ≠ ⊥), x ≤ y → x.unbot hx ≤ y.unbot hy | **Alias** of the reverse direction of `WithBot.unbot_le_unbot_iff`. | true |
Algebra.traceMatrix._proof_1 | Mathlib.RingTheory.Trace.Basic | ∀ (A : Type u_1) [inst : CommRing A], SMulCommClass A A A | null | false |
Real.strictAntiOn_rpow_Ioi_of_exponent_neg | Mathlib.Analysis.SpecialFunctions.Pow.Real | ∀ {r : ℝ}, r < 0 → StrictAntiOn (fun x => x ^ r) (Set.Ioi 0) | null | true |
antisymm_of | Mathlib.Order.Defs.Unbundled | ∀ {α : Sort u_1} (r : α → α → Prop) [Std.Antisymm r] {a b : α}, r a b → r b a → a = b | A version of `antisymm` with `r` explicit.
This lemma matches the lemmas from lean core in `Init.Algebra.Classes`, but is missing there. | true |
isPurelyInseparable_iff | Mathlib.FieldTheory.PurelyInseparable.Basic | ∀ {F : Type u_1} {E : Type u_2} [inst : CommRing F] [inst_1 : Ring E] [inst_2 : Algebra F E],
IsPurelyInseparable F E ↔ ∀ (x : E), IsIntegral F x ∧ (IsSeparable F x → x ∈ (algebraMap F E).range) | null | true |
RatFunc.num_inv_dvd | Mathlib.FieldTheory.RatFunc.Basic | ∀ {K : Type u} [inst : Field K] {x : RatFunc K}, x ≠ 0 → x⁻¹.num ∣ x.denom | null | true |
Cardinal.mk_finsupp_lift_of_infinite' | Mathlib.SetTheory.Cardinal.Finsupp | ∀ (α : Type u) (β : Type v) [Nonempty α] [inst : Zero β] [Infinite β],
Cardinal.mk (α →₀ β) = max (Cardinal.lift.{v, u} (Cardinal.mk α)) (Cardinal.lift.{u, v} (Cardinal.mk β)) | null | true |
Batteries.PairingHeap.headI | Batteries.Data.PairingHeap | {α : Type u} → {le : α → α → Bool} → [Inhabited α] → Batteries.PairingHeap α le → α | `O(1)`. Returns the smallest element in the heap, or `default` if the heap is empty. | true |
ContinuousMap.instStar | Mathlib.Topology.ContinuousMap.Star | {α : Type u_2} →
{β : Type u_3} →
[inst : TopologicalSpace α] → [inst_1 : TopologicalSpace β] → [inst_2 : Star β] → [ContinuousStar β] → Star C(α, β) | null | true |
GroupNorm.instOne._proof_1 | Mathlib.Analysis.Normed.Group.Seminorm | ∀ {E : Type u_1} [inst : Group E] [inst_1 : DecidableEq E] (x : E), (if x = 1 then 0 else 1) = 0 → x = 1 | null | false |
antitoneOn_of_le_sub_one | Mathlib.Algebra.Order.SuccPred | ∀ {α : Type u_2} {β : Type u_3} [inst : PartialOrder α] [inst_1 : Preorder β] [inst_2 : Sub α] [inst_3 : One α]
[inst_4 : PredSubOrder α] [IsPredArchimedean α] {s : Set α} {f : α → β},
s.OrdConnected → (∀ (a : α), ¬IsMin a → a ∈ s → a - 1 ∈ s → f a ≤ f (a - 1)) → AntitoneOn f s | null | true |
CommGroup.toDistribLattice._proof_1 | Mathlib.Algebra.Order.Group.Lattice | ∀ (α : Type u_1) [inst : Lattice α] [inst_1 : CommGroup α] [MulLeftMono α] (x y z : α), (x ⊔ y) ⊓ (x ⊔ z) ≤ x ⊔ y ⊓ z | null | false |
Lean.Elab.Term.ToDepElimPattern.State._sizeOf_inst | Lean.Elab.Match | SizeOf Lean.Elab.Term.ToDepElimPattern.State | null | false |
SimpleGraph.Hom.ofLE_apply | Mathlib.Combinatorics.SimpleGraph.Maps | ∀ {V : Type u_1} {G₁ G₂ : SimpleGraph V} (h : G₁ ≤ G₂) (v : V), (SimpleGraph.Hom.ofLE h) v = v | null | true |
AdjoinRoot.instNumberFieldRat | Mathlib.NumberTheory.NumberField.Basic | ∀ {f : Polynomial ℚ} [hf : Fact (Irreducible f)], NumberField (AdjoinRoot f) | The quotient of `ℚ[X]` by the ideal generated by an irreducible polynomial of `ℚ[X]`
is a number field. | true |
Int.le_add_of_sub_left_le | Init.Data.Int.Order | ∀ {a b c : ℤ}, a - b ≤ c → a ≤ b + c | null | true |
Lean.ResolveName.resolveNamespaceUsingOpenDecls | Lean.ResolveName | Lean.Environment → Lean.Name → List Lean.OpenDecl → List Lean.Name | null | true |
HomotopicalAlgebra.PrepathObject.map_p₁ | Mathlib.AlgebraicTopology.ModelCategory.PathObject | ∀ {C : Type u} [inst : CategoryTheory.Category.{v, u} C] {X : C} (P : HomotopicalAlgebra.PrepathObject X) {D : Type u_1}
[inst_1 : CategoryTheory.Category.{v_1, u_1} D] (F : CategoryTheory.Functor C D), (P.map F).p₁ = F.map P.p₁ | null | true |
_private.Mathlib.Algebra.DirectSum.Basic.0.DirectSum.map_eq_iff._simp_1_1 | Mathlib.Algebra.DirectSum.Basic | ∀ {ι : Type v} {β : ι → Type w} [inst : (i : ι) → AddCommMonoid (β i)] {x y : DirectSum ι β},
(x = y) = ∀ (i : ι), x i = y i | null | false |
SkewMonoidAlgebra.algHom_ext | Mathlib.Algebra.SkewMonoidAlgebra.Basic | ∀ {k : Type u_1} {G : Type u_2} [inst : Monoid G] [inst_1 : CommSemiring k] {A : Type u_3} [inst_2 : Semiring A]
[inst_3 : Algebra k A] [inst_4 : MulSemiringAction G k] [inst_5 : SMulCommClass G k k]
⦃φ₁ φ₂ : SkewMonoidAlgebra k G →ₐ[k] A⦄,
(∀ (x : G), φ₁ (SkewMonoidAlgebra.single x 1) = φ₂ (SkewMonoidAlgebra.sin... | A `k`-algebra homomorphism from `SkewMonoidAlgebra k G` is uniquely defined by its
values on the functions `single a 1`. | true |
Mathlib.Meta.FunProp.LambdaTheoremArgs.ctorIdx | Mathlib.Tactic.FunProp.Theorems | Mathlib.Meta.FunProp.LambdaTheoremArgs → ℕ | null | false |
_private.Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex.0.Complex.cos_eq_cos_iff._simp_1_3 | Mathlib.Analysis.SpecialFunctions.Trigonometric.Complex | ∀ {G : Type u_3} [inst : AddGroup G] {a b c : G}, (a - b = c) = (a = c + b) | null | false |
Algebra.FormallyUnramified.localization_base | Mathlib.RingTheory.Unramified.Basic | ∀ {R : Type u_1} {Rₘ : Type u_3} {Sₘ : Type u_4} [inst : CommRing R] [inst_1 : CommRing Rₘ] [inst_2 : CommRing Sₘ]
(M : Submonoid R) [inst_3 : Algebra R Sₘ] [inst_4 : Algebra R Rₘ] [inst_5 : Algebra Rₘ Sₘ] [IsScalarTower R Rₘ Sₘ]
[Algebra.FormallyUnramified R Sₘ], Algebra.FormallyUnramified Rₘ Sₘ | This actually does not need the localization instance, and is stated here again for
consistency. See `Algebra.FormallyUnramified.of_comp` instead.
The intended use is for copying proofs between `Formally{Unramified, Smooth, Etale}`
without the need to change anything (including removing redundant arguments). | true |
_private.Batteries.Data.MLList.Basic.0.MLList.specImpl | Batteries.Data.MLList.Basic | (m : Type u_1 → Type u_1) → MLList.Spec✝ m | null | true |
Lean.Omega.LinearCombo.sub | Init.Omega.LinearCombo | Lean.Omega.LinearCombo → Lean.Omega.LinearCombo → Lean.Omega.LinearCombo | Implementation of subtraction on `LinearCombo`. | true |
AddCommMonCat.FilteredColimits.M | Mathlib.Algebra.Category.MonCat.FilteredColimits | {J : Type v} →
[inst : CategoryTheory.SmallCategory J] →
[CategoryTheory.IsFiltered J] → CategoryTheory.Functor J AddCommMonCat → AddMonCat | The colimit of `F ⋙ forget₂ AddCommMonCat AddMonCat` in the category `AddMonCat`. In the
following, we will show that this has the structure of a _commutative_ additive monoid. | true |
_private.Std.Time.Date.ValidDate.0.Std.Time.ValidDate.ofOrdinal._proof_6 | Std.Time.Date.ValidDate | ∀ (idx : Std.Time.Month.Ordinal) (acc : ℤ),
12 ≤ ↑idx → ∀ (ordinal : Std.Time.Day.Ordinal.OfYear true), ↑ordinal ≤ 366 → 366 < ↑ordinal → False | null | false |
Vector.findFinIdx?_singleton._proof_1 | Init.Data.Vector.Find | ∀ {α : Type u_1} {a : α}, 0 < #[a].size | null | false |
_private.Mathlib.Data.Nat.Cast.NeZero.0.NeZero.one_le._proof_1_1 | Mathlib.Data.Nat.Cast.NeZero | ∀ {n : ℕ}, n ≠ 0 → 1 ≤ n | null | false |
CategoryTheory.Preadditive.toCommGrp_obj_grp | Mathlib.CategoryTheory.Preadditive.CommGrp_ | ∀ (C : Type u) [inst : CategoryTheory.Category.{v, u} C] [inst_1 : CategoryTheory.Preadditive C]
[inst_2 : CategoryTheory.CartesianMonoidalCategory C] [inst_3 : CategoryTheory.BraidedCategory C] (X : C),
((CategoryTheory.Preadditive.toCommGrp C).obj X).grp = CategoryTheory.Preadditive.instGrpObj X | null | true |
Plausible.Gen.oneOfWithDefault | Plausible.Gen | {α : Type} → Plausible.Gen α → List (Plausible.Gen α) → Plausible.Gen α | Picks one of the generators in `gs` at random, returning the `default` generator
if `gs` is empty.
(This is a more ergonomic version of Plausible's `Gen.oneOf` which doesn't
require the caller to supply a proof that the list index is in bounds.) | true |
CategoryTheory.FinCategory.objAsTypeToAsType | Mathlib.CategoryTheory.FinCategory.AsType | (α : Type u_1) →
[inst : Fintype α] →
[inst_1 : CategoryTheory.SmallCategory α] →
[inst_2 : CategoryTheory.FinCategory α] →
CategoryTheory.Functor (CategoryTheory.FinCategory.ObjAsType α) (CategoryTheory.FinCategory.AsType α) | The "identity" functor from `ObjAsType α` to `AsType α`. | true |
CategoryTheory.Limits.FormalCoproduct.homPullbackEquiv._proof_4 | Mathlib.CategoryTheory.Limits.FormalCoproducts.Basic | ∀ {C : Type u_1} [inst : CategoryTheory.Category.{u_3, u_1} C] {X Y Z : CategoryTheory.Limits.FormalCoproduct C}
(f : X ⟶ Z) (g : Y ⟶ Z) (T : CategoryTheory.Limits.FormalCoproduct C)
(s : { p // CategoryTheory.CategoryStruct.comp p.1 f = CategoryTheory.CategoryStruct.comp p.2 g }) (i : T.I),
Z.obj (f.f (↑⟨((↑s).1... | null | false |
_private.Mathlib.Tactic.Ring.Common.0.Mathlib.Tactic.Ring.Common.ExBase.toProd.match_1 | Mathlib.Tactic.Ring.Common | {u : Lean.Level} →
{α : Q(Type u)} →
{bt : Q(«$α») → Type} →
{sα : Q(CommSemiring «$α»)} →
(motive : Mathlib.Tactic.Ring.Common.Result bt q(Nat.rawCast 1) → Sort u_1) →
(x : Mathlib.Tactic.Ring.Common.Result bt q(Nat.rawCast 1)) →
((expr : Q(«$α»)) →
(one : bt e... | null | false |
LinearOrder.mkOfAddGroupCone.eq_1 | Mathlib.Algebra.Order.Group.Cone | ∀ {S : Type u_1} {G : Type u_2} [inst : AddCommGroup G] [inst_1 : SetLike S G] (C : S) [inst_2 : AddGroupConeClass S G]
[inst_3 : HasMemOrNegMem C] [inst_4 : DecidablePred fun x => x ∈ C],
LinearOrder.mkOfAddGroupCone C =
{ toPartialOrder := PartialOrder.mkOfAddGroupCone C, min := fun a b => if a ≤ b then a els... | null | true |
PEquiv.trans_assoc | Mathlib.Basic.PEquiv | ∀ {α : Type u} {β : Type v} {γ : Type w} {δ : Type x} (f : α ≃. β) (g : β ≃. γ) (h : γ ≃. δ),
(f.trans g).trans h = f.trans (g.trans h) | null | true |
Path.Homotopic.proj.eq_1 | Mathlib.Topology.Homotopy.Product | ∀ {ι : Type u_1} {X : ι → Type u_2} [inst : (i : ι) → TopologicalSpace (X i)] {as bs : (i : ι) → X i} (i : ι)
(p : Path.Homotopic.Quotient as bs), Path.Homotopic.proj i p = p.map { toFun := fun p => p i, continuous_toFun := ⋯ } | null | true |
UInt16.ofInt_one | Init.Data.UInt.Lemmas | UInt16.ofInt 1 = 1 | null | true |
FormalMultilinearSeries.id._proof_4 | Mathlib.Analysis.Analytic.Composition | ∀ (𝕜 : Type u_1) (E : Type u_2) [inst : NontriviallyNormedField 𝕜] [inst_1 : NormedAddCommGroup E]
[inst_2 : NormedSpace 𝕜 E], ContinuousConstSMul 𝕜 E | null | false |
Equiv.Perm.Basis.toCentralizer_apply | Mathlib.GroupTheory.Perm.Centralizer | ∀ {α : Type u_1} [inst : DecidableEq α] [inst_1 : Fintype α] {g : Equiv.Perm α} (a : g.Basis)
(τ : ↥(Equiv.Perm.OnCycleFactors.range_toPermHom' g)) (x : α), ↑(a.toCentralizer τ) x = a.ofPermHomFun τ x | null | true |
_private.Batteries.Recycling.RBTree.Lemmas.0.RBTree.RBNode.setRoot.match_1.splitter | Batteries.Recycling.RBTree.Lemmas | {α : Type u_1} →
(motive : RBTree.RBNode α → Sort u_2) →
(x : RBTree.RBNode α) →
(Unit → motive RBTree.RBNode.nil) →
((c : RBTree.RBColor) →
(a : RBTree.RBNode α) → (v : α) → (b : RBTree.RBNode α) → motive (RBTree.RBNode.node c a v b)) →
motive x | null | true |
GaloisCoinsertion.liftCompleteLattice.eq_1 | Mathlib.Order.GaloisConnection.Basic | ∀ {α : Type u_1} {β : Type u_2} {l : α → β} {u : β → α} [inst : PartialOrder β] [inst_1 : CompleteLattice α]
(gi : GaloisCoinsertion u l),
gi.liftCompleteLattice =
{ toLattice := gi.liftLattice, sSup := fun s => gi.choice (sSup (u '' s)) ⋯, isLUB_sSup := ⋯,
sInf := fun s => l (sInf (u '' s)), isGLB_sInf :... | null | true |
WithOne.lift_symm_injective_of_injective | Mathlib.Algebra.Group.WithOne.Basic | ∀ {α : Type u} {β : Type v} [inst : Mul α] [inst_1 : MulOneClass β] {f : WithOne α →* β},
Function.Injective ⇑f → Function.Injective ⇑(WithOne.lift.symm f) | null | true |
RBTree.RBNode.fold | Batteries.Recycling.RBTree.Basic | {σ : Sort u_1} → {α : Type u_2} → σ → (σ → α → σ → σ) → RBTree.RBNode α → σ | Fold a function in tree order along the nodes. `v₀` is used at `nil` nodes and
`f` is used to combine results at branching nodes.
| true |
_private.Lean.Meta.InferType.0.Lean.Meta.isProofQuickApp | Lean.Meta.InferType | Lean.Expr → ℕ → Lean.MetaM Lean.LBool | `isProofQuickApp f n` is an "approximate" predicate which returns `LBool.true` if `f` applied to
`n` arguments is a proof.
| true |
ClopenUpperSet.ext_iff | Mathlib.Topology.Sets.Order | ∀ {α : Type u_1} [inst : TopologicalSpace α] [inst_1 : LE α] {s t : ClopenUpperSet α}, s = t ↔ ↑s = ↑t | null | true |
Equiv.ext_iff | Mathlib.Logic.Equiv.Defs | ∀ {α : Sort u} {β : Sort v} {f g : α ≃ β}, f = g ↔ ∀ (x : α), f x = g x | null | true |
_private.Mathlib.Algebra.Polynomial.Derivative.0.Polynomial.iterate_derivative_prod_X_sub_C.match_1_4 | Mathlib.Algebra.Polynomial.Derivative | {R : Type u_1} →
{S : Finset R} →
(k : ℕ) →
(motive :
(x : Finset R × R) →
x ∈
{x ∈ Finset.powersetCard (S.card - k) S ×ˢ S |
match x with
| (T, i) => i ∈ T} →
Sort u_2) →
(x : Finset R × R) →
(x_1 :
... | null | false |
Std.Tactic.BVDecide.BVExpr.bitblast.blastMul.blast | Std.Tactic.BVDecide.Bitblast.BVExpr.Circuit.Impl.Operations.Mul | {α : Type} →
[inst : Hashable α] →
[inst_1 : DecidableEq α] → {w : ℕ} → (aig : Std.Sat.AIG α) → aig.BinaryRefVec w → Std.Sat.AIG.RefVecEntry α w | null | true |
Std.Internal.List.Const.getKeyD_modifyKey_self | Std.Data.Internal.List.Associative | ∀ {α : Type u} {β : Type v} [inst : BEq α] [EquivBEq α] {k fallback : α} {f : β → β} (l : List ((_ : α) × β)),
Std.Internal.List.DistinctKeys l →
Std.Internal.List.getKeyD k (Std.Internal.List.Const.modifyKey k f l) fallback =
if Std.Internal.List.containsKey k l = true then k else fallback | null | true |
String.Slice.Pattern.ForwardSliceSearcher.instToForwardSearcher | Init.Data.String.Pattern.String | {pat : String.Slice} → String.Slice.Pattern.ToForwardSearcher pat String.Slice.Pattern.ForwardSliceSearcher | null | true |
TopCat.GlueData.MkCore.cocycle | Mathlib.Topology.Gluing | ∀ (self : TopCat.GlueData.MkCore) (i j k : self.J) (x : ↥(self.V i j)) (h : ↑x ∈ self.V i k),
↑((CategoryTheory.ConcreteCategory.hom (self.t j k)) ⟨↑((CategoryTheory.ConcreteCategory.hom (self.t i j)) x), ⋯⟩) =
↑((CategoryTheory.ConcreteCategory.hom (self.t i k)) ⟨↑x, h⟩) | null | true |
MonCat.Colimits.monoidColimitType._proof_2 | Mathlib.Algebra.Category.MonCat.Colimits | ∀ {J : Type u_1} [inst : CategoryTheory.Category.{u_2, u_1} J] (F : CategoryTheory.Functor J MonCat) (n : ℕ)
(x : MonCat.Colimits.ColimitType F), x ^ (n + 1) = x ^ n * x | null | false |
LocallyConstant.instAddGroup._proof_6 | Mathlib.Topology.LocallyConstant.Algebra | ∀ {X : Type u_1} {Y : Type u_2} [inst : TopologicalSpace X] [inst_1 : AddGroup Y] (x : LocallyConstant X Y) (x_1 : ℤ),
⇑(x_1 • x) = ⇑(x_1 • x) | null | false |
NormedAddGroupHom.toAddMonoidHomClass | Mathlib.Analysis.Normed.Group.Hom | ∀ {V₁ : Type u_2} {V₂ : Type u_3} [inst : SeminormedAddCommGroup V₁] [inst_1 : SeminormedAddCommGroup V₂],
AddMonoidHomClass (NormedAddGroupHom V₁ V₂) V₁ V₂ | null | true |
WType.instEncodable | Mathlib.Data.W.Basic | {α : Type u_1} →
{β : α → Type u_2} → [(a : α) → Fintype (β a)] → [(a : α) → Encodable (β a)] → [Encodable α] → Encodable (WType β) | `WType` is encodable when `α` is an encodable fintype and for every `a : α`, `β a` is
encodable. | true |
PredOrder.ofPredLeIff | Mathlib.Order.SuccPred.Basic | {α : Type u_1} → [inst : Preorder α] → (pred : α → α) → (∀ {a b : α}, b ≤ pred a ↔ b < a) → PredOrder α | A constructor for `PredOrder α` usable when `α` has no minimal element. | true |
Module.supportDim_le_of_surjective | Mathlib.RingTheory.KrullDimension.Module | ∀ {R : Type u_1} [inst : CommRing R] {M : Type u_2} [inst_1 : AddCommGroup M] [inst_2 : Module R M] {N : Type u_3}
[inst_3 : AddCommGroup N] [inst_4 : Module R N] (f : M →ₗ[R] N),
Function.Surjective ⇑f → Module.supportDim R N ≤ Module.supportDim R M | null | true |
Matroid.cRk_map_eq | Mathlib.Combinatorics.Matroid.Rank.Cardinal | ∀ {α β : Type u} {f : α → β} {X : Set β} (M : Matroid α) (hf : Set.InjOn f M.E), (M.map f hf).cRk X = M.cRk (f ⁻¹' X) | null | true |
Subarray.size_le_array_size | Init.Data.Array.Subarray | ∀ {α : Type u_1} {s : Subarray α}, Std.Slice.size s ≤ s.array.size | null | true |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.