tasksource/leandojo huggingface dataset:
Theorem: Zspan.repr_floor_apply
File: Mathlib/Algebra/Module/Zlattice.lean

tactic: classical simp only [floor, zsmul_eq_smul_cast K, b.repr.map_smul, Finsupp.single_apply,
  Finset.sum_apply', Basis.repr_self, Finsupp.smul_single', mul_one, Finset.sum_ite_eq', coe_sum,
  Finset.mem_univ, if_true, coe_smul_of_tower, Basis.restrictScalars_apply, LinearEquiv.map_sum]
state_before: E : Type u_3
ι : Type u_2
K : Type u_1
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
i : ι
⊢ ↑(↑b.repr ↑(floor b m)) i = ↑⌊↑(↑b.repr m) i⌋

tactic: simp only [floor, zsmul_eq_smul_cast K, b.repr.map_smul, Finsupp.single_apply,
Finset.sum_apply', Basis.repr_self, Finsupp.smul_single', mul_one, Finset.sum_ite_eq', coe_sum,
Finset.mem_univ, if_true, coe_smul_of_tower, Basis.restrictScalars_apply, LinearEquiv.map_sum]
state_before: E : Type u_3
ι : Type u_2
K : Type u_1
inst✝⁴ : NormedLinearOrderedField K
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace K E
b : Basis ι K E
inst✝¹ : FloorRing K
inst✝ : Fintype ι
m : E
i : ι
⊢ ↑(↑b.repr ↑(floor b m)) i = ↑⌊↑(↑b.repr m) i⌋
Theorem: OrthonormalBasis.abs_det_adjustToOrientation
File: Mathlib/Analysis/InnerProductSpace/Orientation.lean

tactic: simp [toBasis_adjustToOrientation]
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace ℝ E
ι : Type u_2
inst✝¹ : Fintype ι
inst✝ : DecidableEq ι
ne : Nonempty ι
e f : OrthonormalBasis ι ℝ E
x : Orientation ℝ E ι
v : ι → E
⊢ abs (↑(Basis.det (OrthonormalBasis.toBasis (adjustToOrientation e x))) v) =
    abs (↑(Basis.det (OrthonormalBasis.toBasis e)) v)
Theorem: Finpartition.isUniformOfEmpty
File: Mathlib/Combinatorics/SimpleGraph/Regularity/Uniform.lean

tactic: simp [IsUniform, hP, nonUniforms]
state_before: α : Type u_1
𝕜 : Type u_2
inst✝² : LinearOrderedField 𝕜
inst✝¹ : DecidableEq α
A : Finset α
P : Finpartition A
G : SimpleGraph α
inst✝ : DecidableRel G.Adj
ε : 𝕜
hP : P.parts = ∅
⊢ IsUniform P G ε
Theorem: AlgebraicGeometry.StructureSheaf.localizationToStalk_stalkSpecializes
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

tactic: apply IsLocalization.ringHom_ext (S := Localization.AtPrime y.asIdeal) y.asIdeal.primeCompl
state_before: R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ localizationToStalk R y ≫ stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h =
    CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h) ≫ localizationToStalk R x

tactic: erw [RingHom.comp_assoc]
state_before: case h
R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ RingHom.comp (localizationToStalk R y ≫ stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h)
      (algebraMap R (Localization.AtPrime y.asIdeal)) =
    RingHom.comp (CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h) ≫ localizationToStalk R x)
      (algebraMap R (Localization.AtPrime y.asIdeal))

tactic: conv_rhs => erw [RingHom.comp_assoc]
state_before: case h
R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ RingHom.comp (stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h)
      (RingHom.comp (localizationToStalk R y) (algebraMap R (Localization.AtPrime y.asIdeal))) =
    RingHom.comp (CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h) ≫ localizationToStalk R x)
      (algebraMap R (Localization.AtPrime y.asIdeal))

tactic: dsimp [CommRingCat.ofHom, localizationToStalk, PrimeSpectrum.localizationMapOfSpecializes]
state_before: case h
R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ RingHom.comp (stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h)
      (RingHom.comp (localizationToStalk R y) (algebraMap R (Localization.AtPrime y.asIdeal))) =
    RingHom.comp (localizationToStalk R x)
      (RingHom.comp (CommRingCat.ofHom (PrimeSpectrum.localizationMapOfSpecializes h))
        (algebraMap R (Localization.AtPrime y.asIdeal)))

tactic: rw [IsLocalization.lift_comp, IsLocalization.lift_comp, IsLocalization.lift_comp]
state_before: case h
R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ RingHom.comp (stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h)
      (RingHom.comp
        (IsLocalization.lift (_ : ∀ (f : { x // x ∈ Ideal.primeCompl y.asIdeal }), IsUnit (↑(toStalk R y) ↑f)))
        (algebraMap R (Localization.AtPrime y.asIdeal))) =
    RingHom.comp
      (IsLocalization.lift (_ : ∀ (f : { x_1 // x_1 ∈ Ideal.primeCompl x.asIdeal }), IsUnit (↑(toStalk R x) ↑f)))
      (RingHom.comp
        (IsLocalization.lift
          (_ :
            ∀ (y_1 : { x // x ∈ Ideal.primeCompl y.asIdeal }),
              IsUnit (↑(algebraMap R (Localization.AtPrime x.asIdeal)) ↑y_1)))
        (algebraMap R (Localization.AtPrime y.asIdeal)))

tactic: exact toStalk_stalkSpecializes h
state_before: case h
R✝ : Type u
inst✝¹ : CommRing R✝
R : Type u_1
inst✝ : CommRing R
x y : PrimeSpectrum R
h : x ⤳ y
⊢ RingHom.comp (stalkSpecializes (Sheaf.presheaf (structureSheaf R)) h) (toStalk R y) = toStalk R x
Theorem: CauSeq.const_le
File: Mathlib/Data/Real/CauSeq.lean

tactic: rw [le_iff_lt_or_eq]
state_before: α : Type u_1
inst✝ : LinearOrderedField α
x y : α
⊢ const x ≤ const y ↔ x ≤ y

tactic: exact or_congr const_lt const_equiv
state_before: α : Type u_1
inst✝ : LinearOrderedField α
x y : α
⊢ const x ≤ const y ↔ x < y ∨ x = y
Theorem: smul_ball_one
File: Mathlib/Analysis/Normed/Group/Pointwise.lean

tactic: rw [smul_ball, smul_eq_mul, mul_one]
state_before: E : Type u_1
inst✝ : SeminormedCommGroup E
ε δ : ℝ
s t : Set E
x y : E
⊢ x • ball 1 δ = ball x δ
Theorem: Rat.normalize_eq_mkRat
File: Std/Data/Rat/Lemmas.lean

tactic: simp [mkRat, den_nz]
state_before: num : Int
den : Nat
den_nz : den ≠ 0
⊢ normalize num den = mkRat num den
Theorem: Fin.repeat_succ
File: Mathlib/Data/Fin/Tuple/Basic.lean

tactic: generalize_proofs h
state_before: m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
⊢ repeat (Nat.succ m) a = append a (repeat m a) ∘ ↑(cast (_ : Nat.succ m * n = n + m * n))

tactic: apply funext
state_before: m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
h : Nat.succ m * n = n + m * n
⊢ repeat (Nat.succ m) a = append a (repeat m a) ∘ ↑(cast h)

tactic: rw [(Fin.cast h.symm).surjective.forall]
state_before: case h
m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
h : Nat.succ m * n = n + m * n
⊢ ∀ (x : Fin (Nat.succ m * n)), repeat (Nat.succ m) a x = (append a (repeat m a) ∘ ↑(cast h)) x

tactic: refine' Fin.addCases (fun l => _) fun r => _
state_before: case h
m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
h : Nat.succ m * n = n + m * n
⊢ ∀ (x : Fin (n + m * n)),
    repeat (Nat.succ m) a (↑(cast (_ : n + m * n = Nat.succ m * n)) x) =
      (append a (repeat m a) ∘ ↑(cast h)) (↑(cast (_ : n + m * n = Nat.succ m * n)) x)

tactic: simp [modNat, Nat.mod_eq_of_lt l.is_lt]
state_before: case h.refine'_1
m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
h : Nat.succ m * n = n + m * n
l : Fin n
⊢ repeat (Nat.succ m) a (↑(cast (_ : n + m * n = Nat.succ m * n)) (↑(castAdd (m * n)) l)) =
    (append a (repeat m a) ∘ ↑(cast h)) (↑(cast (_ : n + m * n = Nat.succ m * n)) (↑(castAdd (m * n)) l))

tactic: simp [modNat]
state_before: case h.refine'_2
m✝ n : ℕ
α✝ : Fin (n + 1) → Type u
x : α✝ 0
q : (i : Fin (n + 1)) → α✝ i
p : (i : Fin n) → α✝ (succ i)
i : Fin n
y : α✝ (succ i)
z : α✝ 0
α : Type u_1
a : Fin n → α
m : ℕ
h : Nat.succ m * n = n + m * n
r : Fin (m * n)
⊢ repeat (Nat.succ m) a (↑(cast (_ : n + m * n = Nat.succ m * n)) (↑(natAdd n) r)) =
    (append a (repeat m a) ∘ ↑(cast h)) (↑(cast (_ : n + m * n = Nat.succ m * n)) (↑(natAdd n) r))
Theorem: SimpleGraph.Walk.support_map
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: induction p <;> simp [*]
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
f : G →g G'
f' : G' →g G''
u v u' v' : V
p : Walk G u v
⊢ support (Walk.map f p) = List.map (↑f) (support p)
Theorem: EuclideanGeometry.inversion_self
File: Mathlib/Geometry/Euclidean/Inversion.lean

tactic: simp [inversion]
state_before: V : Type u_2
P : Type u_1
inst✝³ : NormedAddCommGroup V
inst✝² : InnerProductSpace ℝ V
inst✝¹ : MetricSpace P
inst✝ : NormedAddTorsor V P
a b c✝ d x y z : P
R✝ : ℝ
c : P
R : ℝ
⊢ inversion c R c = c
Theorem: SatisfiesM_ReaderT_eq
File: Std/Classes/LawfulMonad.lean

tactic: exact ⟨fun eq _ => eq ▸ rfl, funext⟩
state_before: m : Type u_1 → Type u_2
ρ α✝ : Type u_1
p : α✝ → Prop
x : ReaderT ρ m α✝
inst✝ : Monad m
a : ReaderT ρ m { a // p a }
⊢ Subtype.val <$> a = x ↔ ∀ (x_1 : ρ), Subtype.val <$> a x_1 = x x_1
Theorem: FractionalIdeal.map_symm_map
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: rw [← map_comp, g.comp_symm, map_id]
state_before: R : Type u_1
inst✝⁶ : CommRing R
S : Submonoid R
P : Type u_3
inst✝⁵ : CommRing P
inst✝⁴ : Algebra R P
loc : IsLocalization S P
P' : Type u_2
inst✝³ : CommRing P'
inst✝² : Algebra R P'
loc' : IsLocalization S P'
P'' : Type ?u.574326
inst✝¹ : CommRing P''
inst✝ : Algebra R P''
loc'' : IsLocalization S P''
I✝ J : FractionalIdeal S P
g✝ : P →ₐ[R] P'
I : FractionalIdeal S P'
g : P ≃ₐ[R] P'
⊢ map (↑g) (map (↑(AlgEquiv.symm g)) I) = I
Theorem: IsUnit.mul_one_div_cancel
File: Mathlib/Algebra/Hom/Units.lean

tactic: simp [h]
state_before: F : Type ?u.54504
G : Type ?u.54507
α : Type u_1
M : Type ?u.54513
N : Type ?u.54516
inst✝ : DivisionMonoid α
a b c : α
h : IsUnit a
⊢ a * (1 / a) = 1
Theorem: Stream'.WSeq.destruct_tail
File: Mathlib/Data/Seq/WSeq.lean

tactic: simp [tail]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ destruct (tail s) = destruct s >>= tail.aux

tactic: rw [← bind_pure_comp, LawfulMonad.bind_assoc]
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun o => Option.rec nil Prod.snd o) <$> destruct s >>= destruct = do
    let x ← destruct s
    match x with
      | none => Computation.pure none
      | some (fst, s) => destruct s

tactic: apply congr_arg
state_before: α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (destruct s >>= fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = do
    let x ← destruct s
    match x with
      | none => Computation.pure none
      | some (fst, s) => destruct s

tactic: ext1 (_ | ⟨a, s⟩) <;> apply (@pure_bind Computation _ _ _ _ _ _).trans _ <;> simp
state_before: case h
α : Type u
β : Type v
γ : Type w
s : WSeq α
⊢ (fun x => Pure.pure (Option.rec nil Prod.snd x) >>= destruct) = fun x =>
    match x with
    | none => Computation.pure none
    | some (fst, s) => destruct s
Theorem: Nat.NormDigits.digits_one
File: Mathlib/Data/Nat/Digits.lean

tactic: have b2 : 1 < b :=
  lt_iff_add_one_le.mpr (le_trans (add_le_add_right (lt_iff_add_one_le.mp n0) 1) nb)
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
⊢ digits b n = [n] ∧ 1 < b ∧ 0 < n

tactic: refine' ⟨_, b2, n0⟩
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ digits b n = [n] ∧ 1 < b ∧ 0 < n

tactic: rw [Nat.digits_def' b2 n0, Nat.mod_eq_of_lt nb,
  (Nat.div_eq_zero_iff ((zero_le n).trans_lt nb)).2 nb, Nat.digits_zero]
state_before: n✝ b n : ℕ
n0 : 0 < n
nb : n < b
b2 : 1 < b
⊢ digits b n = [n]
Theorem: LinearMap.map_mul_algebraMap
File: Mathlib/Algebra/Algebra/Basic.lean

tactic: rw [← Algebra.commutes, ← Algebra.commutes, map_algebraMap_mul]
state_before: R : Type u_1
A : Type u_2
B : Type u_3
inst✝⁴ : CommSemiring R
inst✝³ : Semiring A
inst✝² : Semiring B
inst✝¹ : Algebra R A
inst✝ : Algebra R B
f : A →ₗ[R] B
a : A
r : R
⊢ ↑f (a * ↑(algebraMap R A) r) = ↑f a * ↑(algebraMap R B) r
Theorem: Polynomial.trailingDegree_ne_of_natTrailingDegree_ne
File: Mathlib/Data/Polynomial/Degree/TrailingDegree.lean

tactic: have : Nat.cast n = WithTop.some n := rfl
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
⊢ natTrailingDegree p ≠ n → trailingDegree p ≠ ↑n

tactic: exact mt fun h => by rw [natTrailingDegree, h, this, ←WithTop.some_eq_coe, Option.getD_coe]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
this : ↑n = ↑n
⊢ natTrailingDegree p ≠ n → trailingDegree p ≠ ↑n

tactic: rw [natTrailingDegree, h, this, ←WithTop.some_eq_coe, Option.getD_coe]
state_before: R : Type u
S : Type v
a b : R
n✝ m : ℕ
inst✝ : Semiring R
p q r : R[X]
n : ℕ
this : ↑n = ↑n
h : trailingDegree p = ↑n
⊢ natTrailingDegree p = n
Theorem: BoxIntegral.IntegrationParams.MemBaseSet.unionComplToSubordinate
File: Mathlib/Analysis/BoxIntegral/Partition/Filter.lean

tactic: simp
state_before: ι : Type u_1
inst✝ : Fintype ι
I J : Box ι
c c₁ c₂ : ℝ≥0
r r₁ r₂ : (ι → ℝ) → ↑(Set.Ioi 0)
π π₁ π₂✝ : TaggedPrepartition I
l l₁ l₂ : IntegrationParams
hπ₁ : MemBaseSet l I c r₁ π₁
hle : ∀ (x : ι → ℝ), x ∈ ↑Box.Icc I → r₂ x ≤ r₁ x
π₂ : Prepartition I
hU : Prepartition.iUnion π₂ = ↑I \ TaggedPrepartition.iUnion π₁
hc : l.bDistortion = true → Prepartition.distortion π₂ ≤ c
x✝ : l.bDistortion = true
⊢ Prepartition.iUnion ⊥ = ↑I \ TaggedPrepartition.iUnion (unionComplToSubordinate π₁ π₂ hU r₂) ∧
    Prepartition.distortion ⊥ ≤ c
Theorem: Finsupp.LinearEquiv.finsuppUnique_symm_apply
File: Mathlib/LinearAlgebra/Basic.lean

tactic: ext
state_before: R : Type u_3
R₁ : Type ?u.31136
R₂ : Type ?u.31139
R₃ : Type ?u.31142
R₄ : Type ?u.31145
S : Type ?u.31148
K : Type ?u.31151
K₂ : Type ?u.31154
M : Type u_2
M' : Type ?u.31160
M₁ : Type ?u.31163
M₂ : Type ?u.31166
M₃ : Type ?u.31169
M₄ : Type ?u.31172
N : Type ?u.31175
N₂ : Type ?u.31178
ι : Type ?u.31181
V : Type ?u.31184
V₂ : Type ?u.31187
α✝ : Type ?u.31190
inst✝⁴ : Finite α✝
inst✝³ : AddCommMonoid M
inst✝² : Semiring R
inst✝¹ : Module R M
α : Type u_1
inst✝ : Unique α
m : M
⊢ ↑(LinearEquiv.symm (finsuppUnique R M α)) m = single default m

tactic: simp [LinearEquiv.finsuppUnique, Equiv.funUnique, single, Pi.single,
equivFunOnFinite, Function.update]
state_before: case h
R : Type u_3
R₁ : Type ?u.31136
R₂ : Type ?u.31139
R₃ : Type ?u.31142
R₄ : Type ?u.31145
S : Type ?u.31148
K : Type ?u.31151
K₂ : Type ?u.31154
M : Type u_2
M' : Type ?u.31160
M₁ : Type ?u.31163
M₂ : Type ?u.31166
M₃ : Type ?u.31169
M₄ : Type ?u.31172
N : Type ?u.31175
N₂ : Type ?u.31178
ι : Type ?u.31181
V : Type ?u.31184
V₂ : Type ?u.31187
α✝ : Type ?u.31190
inst✝⁴ : Finite α✝
inst✝³ : AddCommMonoid M
inst✝² : Semiring R
inst✝¹ : Module R M
α : Type u_1
inst✝ : Unique α
m : M
⊢ ↑(↑(LinearEquiv.symm (finsuppUnique R M α)) m) default = ↑(single default m) default
Theorem: Finsupp.span_single_image
File: Mathlib/LinearAlgebra/Finsupp.lean

tactic: rw [← span_image]
state_before: α : Type u_2
M : Type u_1
N : Type ?u.43675
P : Type ?u.43678
R : Type u_3
S : Type ?u.43684
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set M
a : α
⊢ span R (single a '' s) = map (lsingle a) (span R s)

tactic: rfl
state_before: α : Type u_2
M : Type u_1
N : Type ?u.43675
P : Type ?u.43678
R : Type u_3
S : Type ?u.43684
inst✝⁷ : Semiring R
inst✝⁶ : Semiring S
inst✝⁵ : AddCommMonoid M
inst✝⁴ : Module R M
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid P
inst✝ : Module R P
s : Set M
a : α
⊢ span R (single a '' s) = span R (↑(lsingle a) '' s)
Theorem: Bool.sizeOf_eq_one
File: src/lean/Init/SizeOf.lean

tactic: cases b <;> rfl
state_before: b : Bool
⊢ sizeOf b = 1
Theorem: Function.periodicOrbit_length
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [periodicOrbit, Cycle.length_coe, List.length_map, List.length_range]
state_before: α : Type u_1
β : Type ?u.29967
f fa : α → α
fb : β → β
x y : α
m n : ℕ
⊢ Cycle.length (periodicOrbit f x) = minimalPeriod f x
Theorem: Real.add_one_le_exp_of_nonneg
File: Mathlib/Data/Complex/Exponential.lean

tactic: rcases eq_or_lt_of_le hx with (rfl | h)
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ x + 1 ≤ exp x

tactic: exact (add_one_lt_exp_of_pos h).le
state_before: case inr
x✝ y x : ℝ
hx : 0 ≤ x
h : 0 < x
⊢ x + 1 ≤ exp x

tactic: simp
state_before: case inl
x y : ℝ
hx : 0 ≤ 0
⊢ 0 + 1 ≤ exp 0
Theorem: IsIntegralClosure.mk'_one
File: Mathlib/RingTheory/IntegralClosure.lean

tactic: rw [algebraMap_mk', RingHom.map_one]
state_before: R : Type u_1
A : Type u_3
B : Type u_2
inst✝⁵ : CommRing R
inst✝⁴ : CommRing A
inst✝³ : CommRing B
inst✝² : Algebra R B
inst✝¹ : Algebra A B
inst✝ : IsIntegralClosure A R B
h : optParam (IsIntegral R 1) (_ : IsIntegral R 1)
⊢ ↑(algebraMap A B) (mk' A 1 h) = ↑(algebraMap A B) 1
Theorem: Nat.lt_of_add_lt_add_left
File: Std/Data/Nat/Lemmas.lean

tactic: rwa [heq] at h
state_before: k n m : Nat
h : k + n < k + m
heq : n = m
⊢ k + m < k + m
Theorem: Stream'.mem_map
File: Mathlib/Data/Stream/Init.lean

tactic: rw [nth_map, h]
state_before: α : Type u
β : Type v
δ : Type w
f : α → β
a : α
s : Stream' α
x✝ : a ∈ s
n : ℕ
h : (fun b => a = b) (nth s n)
⊢ (fun b => f a = b) (nth (map f s) n)
Theorem: Set.left_mem_Ico
File: Mathlib/Data/Set/Intervals/Basic.lean

tactic: simp [le_refl]
state_before: α : Type u_1
β : Type ?u.3745
inst✝ : Preorder α
a a₁ a₂ b b₁ b₂ c x : α
⊢ a ∈ Ico a b ↔ a < b
Theorem: ContDiffAt.prod_map'
File: Mathlib/Analysis/Calculus/ContDiff.lean

tactic: rcases p with ⟨⟩
state_before: 𝕜 : Type u_2
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type ?u.2192953
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p✝ : E → FormalMultilinearSeries 𝕜 E F
E' : Type u_1
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_3
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
p : E × E'
hf : ContDiffAt 𝕜 n f p.fst
hg : ContDiffAt 𝕜 n g p.snd
⊢ ContDiffAt 𝕜 n (Prod.map f g) p

tactic: exact ContDiffAt.prod_map hf hg
state_before: case mk
𝕜 : Type u_2
inst✝¹⁴ : NontriviallyNormedField 𝕜
D : Type uD
inst✝¹³ : NormedAddCommGroup D
inst✝¹² : NormedSpace 𝕜 D
E : Type uE
inst✝¹¹ : NormedAddCommGroup E
inst✝¹⁰ : NormedSpace 𝕜 E
F : Type uF
inst✝⁹ : NormedAddCommGroup F
inst✝⁸ : NormedSpace 𝕜 F
G : Type uG
inst✝⁷ : NormedAddCommGroup G
inst✝⁶ : NormedSpace 𝕜 G
X : Type ?u.2192953
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedSpace 𝕜 X
s s₁ t u : Set E
f✝ f₁ : E → F
g✝ : F → G
x x₀ : E
c : F
b : E × F → G
m n : ℕ∞
p : E → FormalMultilinearSeries 𝕜 E F
E' : Type u_1
inst✝³ : NormedAddCommGroup E'
inst✝² : NormedSpace 𝕜 E'
F' : Type u_3
inst✝¹ : NormedAddCommGroup F'
inst✝ : NormedSpace 𝕜 F'
f : E → F
g : E' → F'
fst✝ : E
snd✝ : E'
hf : ContDiffAt 𝕜 n f (fst✝, snd✝).fst
hg : ContDiffAt 𝕜 n g (fst✝, snd✝).snd
⊢ ContDiffAt 𝕜 n (Prod.map f g) (fst✝, snd✝)
Theorem: Set.definable_finset_sup
File: Mathlib/ModelTheory/Definability.lean

tactic: classical
  refine' Finset.induction definable_empty (fun i s _ h => _) s
  rw [Finset.sup_insert]
  exact (hf i).union h
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.14150
B : Set M
s✝ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s : Finset ι
⊢ Definable A L (Finset.sup s f)

tactic: refine' Finset.induction definable_empty (fun i s _ h => _) s
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.14150
B : Set M
s✝ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s : Finset ι
⊢ Definable A L (Finset.sup s f)

tactic: rw [Finset.sup_insert]
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.14150
B : Set M
s✝¹ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : ¬i ∈ s
h : Definable A L (Finset.sup s f)
⊢ Definable A L (Finset.sup (insert i s) f)

tactic: exact (hf i).union h
state_before: M : Type w
A : Set M
L : Language
inst✝ : Structure L M
α : Type u₁
β : Type ?u.14150
B : Set M
s✝¹ : Set (α → M)
ι : Type u_1
f : ι → Set (α → M)
hf : ∀ (i : ι), Definable A L (f i)
s✝ : Finset ι
i : ι
s : Finset ι
x✝ : ¬i ∈ s
h : Definable A L (Finset.sup s f)
⊢ Definable A L (f i ⊔ Finset.sup s f)
Theorem: mem_pregroupoid_of_eq_on_source
File: Mathlib/Geometry/Manifold/ChartedSpace.lean

tactic: rw [← he'.1]
state_before: H : Type u
H' : Type ?u.33053
M : Type ?u.33056
M' : Type ?u.33059
M'' : Type ?u.33062
inst✝ : TopologicalSpace H
PG : Pregroupoid H
e e' : LocalHomeomorph H H
he' : e ≈ e'
he : Pregroupoid.property PG (↑e) e.source
⊢ Pregroupoid.property PG (↑e') e'.source

tactic: exact PG.congr e.open_source he'.eqOn.symm he
state_before: H : Type u
H' : Type ?u.33053
M : Type ?u.33056
M' : Type ?u.33059
M'' : Type ?u.33062
inst✝ : TopologicalSpace H
PG : Pregroupoid H
e e' : LocalHomeomorph H H
he' : e ≈ e'
he : Pregroupoid.property PG (↑e) e.source
⊢ Pregroupoid.property PG (↑e') e.source
Theorem: odd_neg_one
File: Mathlib/Algebra/Parity.lean

tactic: simp
state_before: F : Type ?u.103565
α : Type u_1
β : Type ?u.103571
R : Type ?u.103574
inst✝ : Ring α
a b : α
n : ℕ
⊢ Odd (-1)
Theorem: gosper_catalan_sub_eq_central_binom_div
File: Mathlib/Combinatorics/Catalan.lean

tactic: have : (n : ℚ) + 1 ≠ 0 := by norm_cast; exact n.succ_ne_zero
state_before: n : ℕ
⊢ gosperCatalan (n + 1) (n + 1) - gosperCatalan (n + 1) 0 = ↑(Nat.centralBinom (n + 1)) / (↑n + 2)

tactic: have : (n : ℚ) + 1 + 1 ≠ 0 := by norm_cast; exact (n + 1).succ_ne_zero
state_before: n : ℕ
this : ↑n + 1 ≠ 0
⊢ gosperCatalan (n + 1) (n + 1) - gosperCatalan (n + 1) 0 = ↑(Nat.centralBinom (n + 1)) / (↑n + 2)

tactic: have h : (n : ℚ) + 2 ≠ 0 := by norm_cast; exact (n + 1).succ_ne_zero
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
⊢ gosperCatalan (n + 1) (n + 1) - gosperCatalan (n + 1) 0 = ↑(Nat.centralBinom (n + 1)) / (↑n + 2)

tactic: simp only [gosperCatalan, Nat.sub_zero, Nat.centralBinom_zero, Nat.sub_self]
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
h : ↑n + 2 ≠ 0
⊢ gosperCatalan (n + 1) (n + 1) - gosperCatalan (n + 1) 0 = ↑(Nat.centralBinom (n + 1)) / (↑n + 2)

tactic: field_simp
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
h : ↑n + 2 ≠ 0
⊢ ↑(Nat.centralBinom (n + 1)) * ↑1 * (2 * ↑(n + 1) - ↑(n + 1)) / (2 * ↑(n + 1) * (↑(n + 1) + 1)) -
      ↑1 * ↑(Nat.centralBinom (n + 1)) * (2 * ↑0 - ↑(n + 1)) / (2 * ↑(n + 1) * (↑(n + 1) + 1)) =
    ↑(Nat.centralBinom (n + 1)) / (↑n + 2)

tactic: ring
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
h : ↑n + 2 ≠ 0
⊢ (↑(Nat.centralBinom (n + 1)) * (2 * (↑n + 1) - (↑n + 1)) - ↑(Nat.centralBinom (n + 1)) * (-1 + -↑n)) * (↑n + 2) =
    ↑(Nat.centralBinom (n + 1)) * (2 * (↑n + 1) * (↑n + 1 + 1))

tactic: norm_cast
state_before: n : ℕ
⊢ ↑n + 1 ≠ 0

tactic: exact n.succ_ne_zero
state_before: n : ℕ
⊢ ¬n + 1 = 0

tactic: norm_cast
state_before: n : ℕ
this : ↑n + 1 ≠ 0
⊢ ↑n + 1 + 1 ≠ 0

tactic: exact (n + 1).succ_ne_zero
state_before: n : ℕ
this : ↑n + 1 ≠ 0
⊢ ¬n + 1 + 1 = 0

tactic: norm_cast
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
⊢ ↑n + 2 ≠ 0

tactic: exact (n + 1).succ_ne_zero
state_before: n : ℕ
this✝ : ↑n + 1 ≠ 0
this : ↑n + 1 + 1 ≠ 0
⊢ ¬n + 2 = 0