1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: bernsteinPolynomial.derivative_succ
File: Mathlib/RingTheory/Polynomial/Bernstein.lean

tactic: cases n
state_before: R : Type u_1
inst✝ : CommRing R
n ν : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R n (ν + 1)) =
    ↑n * (bernsteinPolynomial R (n - 1) ν - bernsteinPolynomial R (n - 1) (ν + 1))
state_after: case zero
R : Type u_1
inst✝ : CommRing R
ν : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R 0 (ν + 1)) =
    ↑0 * (bernsteinPolynomial R (0 - 1) ν - bernsteinPolynomial R (0 - 1) (ν + 1))

case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R (n✝ + 1) (ν + 1)) =
    ↑(n✝ + 1) * (bernsteinPolynomial R (n✝ + 1 - 1) ν - bernsteinPolynomial R (n✝ + 1 - 1) (ν + 1))

tactic: simp [bernsteinPolynomial]
state_before: case zero
R : Type u_1
inst✝ : CommRing R
ν : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R 0 (ν + 1)) =
    ↑0 * (bernsteinPolynomial R (0 - 1) ν - bernsteinPolynomial R (0 - 1) (ν + 1))
state_after: no goals

tactic: rw [Nat.cast_succ]
state_before: case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R (n✝ + 1) (ν + 1)) =
    ↑(n✝ + 1) * (bernsteinPolynomial R (n✝ + 1 - 1) ν - bernsteinPolynomial R (n✝ + 1 - 1) (ν + 1))
state_after: case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R (n✝ + 1) (ν + 1)) =
    (↑n✝ + 1) * (bernsteinPolynomial R (n✝ + 1 - 1) ν - bernsteinPolynomial R (n✝ + 1 - 1) (ν + 1))

tactic: apply derivative_succ_aux
state_before: case succ
R : Type u_1
inst✝ : CommRing R
ν n✝ : ℕ
⊢ Polynomial.derivative (bernsteinPolynomial R (n✝ + 1) (ν + 1)) =
    (↑n✝ + 1) * (bernsteinPolynomial R (n✝ + 1 - 1) ν - bernsteinPolynomial R (n✝ + 1 - 1) (ν + 1))
state_after: no goals
Theorem: SeparationQuotient.isOpenMap_mk
File: Mathlib/Topology/Inseparable.lean

tactic: rwa [preimage_image_mk_open hs]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
α : Type u_4
ι : Type u_5
π : ι → Type u_6
inst✝³ : TopologicalSpace X
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : (i : ι) → TopologicalSpace (π i)
x y z : X
s✝ : Set X
f g : X → Y
t : Set (SeparationQuotient X)
s : Set X
hs : IsOpen s
⊢ IsOpen (mk ⁻¹' (mk '' s))
state_after: no goals
Theorem: Fin.coe_neg_one
File: Mathlib/Data/Fin/Basic.lean

tactic: cases n
state_before: n m : ℕ
⊢ ↑(-1) = n
state_after: case zero
m : ℕ
⊢ ↑(-1) = 0

case succ
m n✝ : ℕ
⊢ ↑(-1) = n✝ + 1

tactic: rw [Fin.coe_neg, Fin.val_one, Nat.add_one_sub_one, Nat.mod_eq_of_lt]
state_before: case succ
m n✝ : ℕ
⊢ ↑(-1) = n✝ + 1
state_after: case succ
m n✝ : ℕ
⊢ n✝ + 1 < n✝ + 1 + 1

tactic: constructor
state_before: case succ
m n✝ : ℕ
⊢ n✝ + 1 < n✝ + 1 + 1
state_after: no goals

tactic: simp
state_before: case zero
m : ℕ
⊢ ↑(-1) = 0
state_after: no goals
Theorem: MeasureTheory.Measure.restrict_apply₀'
File: Mathlib/MeasureTheory/Measure/Restrict.lean

tactic: rw [← restrict_congr_set hs.toMeasurable_ae_eq,
  restrict_apply' (measurableSet_toMeasurable _ _),
  measure_congr ((ae_eq_refl t).inter hs.toMeasurable_ae_eq)]
state_before: R : Type u_1
α : Type u_2
β : Type u_3
δ : Type u_4
γ : Type u_5
ι : Type u_6
m0 : MeasurableSpace α
inst✝¹ : MeasurableSpace β
inst✝ : MeasurableSpace γ
μ μ₁ μ₂ μ₃ ν ν' ν₁ ν₂ : Measure α
s s' t : Set α
hs : NullMeasurableSet s μ
⊢ (μ.restrict s) t = μ (t ∩ s)
state_after: no goals
Theorem: AlgHom.toLieHom_injective
File: Mathlib/Algebra/Lie/OfAssociative.lean

tactic: ext a
state_before: A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f✝ : A →ₐ[R] B
g✝ : B →ₐ[R] C
f g : A →ₐ[R] B
h : f.toLieHom = g.toLieHom
⊢ f = g
state_after: case H
A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f✝ : A →ₐ[R] B
g✝ : B →ₐ[R] C
f g : A →ₐ[R] B
h : f.toLieHom = g.toLieHom
a : A
⊢ f a = g a

tactic: exact LieHom.congr_fun h a
state_before: case H
A : Type v
inst✝⁶ : Ring A
R : Type u
inst✝⁵ : CommRing R
inst✝⁴ : Algebra R A
B : Type w
C : Type w₁
inst✝³ : Ring B
inst✝² : Ring C
inst✝¹ : Algebra R B
inst✝ : Algebra R C
f✝ : A →ₐ[R] B
g✝ : B →ₐ[R] C
f g : A →ₐ[R] B
h : f.toLieHom = g.toLieHom
a : A
⊢ f a = g a
state_after: no goals
Theorem: WithTop.top_le_iff
File: Mathlib/Order/WithBot.lean

tactic: simp [not_top_le_coe _]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a✝ b : α
inst✝ : LE α
a : α
⊢ ⊤ ≤ ↑a ↔ ↑a = ⊤
state_after: no goals

tactic: simp
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
a b : α
inst✝ : LE α
⊢ ⊤ ≤ ⊤ ↔ ⊤ = ⊤
state_after: no goals
Theorem: AlgebraicGeometry.SheafedSpace.ext
File: Mathlib/Geometry/RingedSpace/SheafedSpace.lean

tactic: rw [w]
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y : SheafedSpace C
α β : X ⟶ Y
w : α.base = β.base
⊢ (Opens.map α.base).op = (Opens.map β.base).op
state_after: no goals
Theorem: Ordinal.type_out
File: Mathlib/SetTheory/Ordinal/Basic.lean

tactic: rw [Ordinal.type, WellOrder.eta, Quotient.out_eq]
state_before: α : Type u
β : Type u_1
γ : Type u_2
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u_3}
⊢ type (Quotient.out o).r = o
state_after: no goals
Theorem: Basis.ofZlatticeBasis_apply
File: Mathlib/Algebra/Module/Zlattice/Basic.lean

tactic: simp [Basis.ofZlatticeBasis]
state_before: K : Type u_1
inst✝⁷ : NormedLinearOrderedField K
inst✝⁶ : HasSolidNorm K
inst✝⁵ : FloorRing K
E : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace K E
inst✝² : FiniteDimensional K E
inst✝¹ : ProperSpace E
L : AddSubgroup E
inst✝ : DiscreteTopology ↥L
ι : Type u_3
hs : IsZlattice K L
b : Basis ι ℤ ↥L
i : ι
⊢ (ofZlatticeBasis K L b) i = ↑(b i)
state_after: no goals
Theorem: Turing.reaches₁_fwd
File: Mathlib/Computability/TuringMachine.lean

tactic: rcases TransGen.head'_iff.1 h₁ with ⟨b', hab, hbc⟩
state_before: σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ : b ∈ f a
⊢ Reaches f b c
state_after: case intro.intro
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ : b ∈ f a
b' : σ
hab : b' ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b' c
⊢ Reaches f b c

tactic: cases Option.mem_unique hab h₂
state_before: case intro.intro
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ : b ∈ f a
b' : σ
hab : b' ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b' c
⊢ Reaches f b c
state_after: case intro.intro.refl
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ hab : b ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b c
⊢ Reaches f b c

tactic: exact hbc
state_before: case intro.intro.refl
σ : Type u_1
f : σ → Option σ
a b c : σ
h₁ : Reaches₁ f a c
h₂ hab : b ∈ f a
hbc : ReflTransGen (fun a b => b ∈ f a) b c
⊢ Reaches f b c
state_after: no goals
Theorem: GeneralizedContinuedFraction.convergents'Aux_succ_none
File: Mathlib/Algebra/ContinuedFractions/Translations.lean

tactic: simp [convergents'Aux, h, convergents'Aux.match_1]
state_before: K : Type u_1
g : GeneralizedContinuedFraction K
n✝ : ℕ
inst✝ : DivisionRing K
s : Stream'.Seq (Pair K)
h : s.head = none
n : ℕ
⊢ convergents'Aux s (n + 1) = 0
state_after: no goals
Theorem: Nat.Ico_filter_pow_dvd_eq
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: ext x
state_before: a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
⊢ Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n) = Finset.filter (fun i => p ^ i ∣ n) (Icc 1 b)
state_after: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
⊢ x ∈ Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n) ↔ x ∈ Finset.filter (fun i => p ^ i ∣ n) (Icc 1 b)

tactic: simp only [Finset.mem_filter, mem_Ico, mem_Icc, and_congr_left_iff, and_congr_right_iff]
state_before: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
⊢ x ∈ Finset.filter (fun i => p ^ i ∣ n) (Ico 1 n) ↔ x ∈ Finset.filter (fun i => p ^ i ∣ n) (Icc 1 b)
state_after: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
⊢ p ^ x ∣ n → 1 ≤ x → (x < n ↔ x ≤ b)

tactic: rintro h1 -
state_before: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
⊢ p ^ x ∣ n → 1 ≤ x → (x < n ↔ x ≤ b)
state_after: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
h1 : p ^ x ∣ n
⊢ x < n ↔ x ≤ b

tactic: exact iff_of_true (lt_of_pow_dvd_right hn pp.two_le h1) <|
  (pow_le_pow_iff_right pp.one_lt).1 <| (le_of_dvd hn.bot_lt h1).trans hb
state_before: case a
a b✝ m n✝ p✝ n p b : ℕ
pp : Prime p
hn : n ≠ 0
hb : n ≤ p ^ b
x : ℕ
h1 : p ^ x ∣ n
⊢ x < n ↔ x ≤ b
state_after: no goals
Theorem: OmegaCompletePartialOrder.ωSup_eq_of_isLUB
File: Mathlib/Order/OmegaCompletePartialOrder.lean

tactic: rw [le_antisymm_iff]
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : IsLUB (Set.range ⇑c) a
⊢ a = ωSup c
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : IsLUB (Set.range ⇑c) a
⊢ a ≤ ωSup c ∧ ωSup c ≤ a

tactic: simp only [IsLUB, IsLeast, upperBounds, lowerBounds, Set.mem_range, forall_exists_index,
  forall_apply_eq_imp_iff, Set.mem_setOf_eq] at h
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : IsLUB (Set.range ⇑c) a
⊢ a ≤ ωSup c ∧ ωSup c ≤ a
state_after: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ a ≤ ωSup c ∧ ωSup c ≤ a

tactic: constructor
state_before: α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ a ≤ ωSup c ∧ ωSup c ≤ a
state_after: case left
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ a ≤ ωSup c

case right
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ωSup c ≤ a

tactic: apply h.2
state_before: case left
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ a ≤ ωSup c
state_after: case left.a
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ∀ (a : ℕ), c a ≤ ωSup c

tactic: exact fun a ↦ le_ωSup c a
state_before: case left.a
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ∀ (a : ℕ), c a ≤ ωSup c
state_after: no goals

tactic: rw [ωSup_le_iff]
state_before: case right
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ωSup c ≤ a
state_after: case right
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ∀ (i : ℕ), c i ≤ a

tactic: apply h.1
state_before: case right
α : Type u
β : Type v
γ : Type u_1
inst✝ : OmegaCompletePartialOrder α
c : Chain α
a : α
h : (∀ (a_1 : ℕ), c a_1 ≤ a) ∧ ∀ ⦃a_1 : α⦄, (∀ (a : ℕ), c a ≤ a_1) → a ≤ a_1
⊢ ∀ (i : ℕ), c i ≤ a
state_after: no goals
Theorem: PMF.toOuterMeasure_bindOnSupport_apply
File: Mathlib/Probability/ProbabilityMassFunction/Monad.lean

tactic: simp only [toOuterMeasure_apply, Set.indicator_apply, bindOnSupport_apply]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
⊢ (p.bindOnSupport f).toOuterMeasure s = ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h).toOuterMeasure s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
⊢ (∑' (x : β), if x ∈ s then ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h) x else 0) =
    ∑' (a : α), p a * if h : p a = 0 then 0 else ∑' (x : β), if x ∈ s then (f a ⋯) x else 0

tactic: calc
  (∑' b, ite (b ∈ s) (∑' a, p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0) =
      ∑' (b) (a), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    tsum_congr fun b => by split_ifs with hbs <;> simp only [eq_self_iff_true, tsum_zero]
  _ = ∑' (a) (b), ite (b ∈ s) (p a * dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    ENNReal.tsum_comm
  _ = ∑' a, p a * ∑' b, ite (b ∈ s) (dite (p a = 0) (fun h => 0) fun h => f a h b) 0 :=
    (tsum_congr fun a => by simp only [← ENNReal.tsum_mul_left, mul_ite, mul_zero])
  _ = ∑' a, p a * dite (p a = 0) (fun h => 0) fun h => ∑' b, ite (b ∈ s) (f a h b) 0 :=
    tsum_congr fun a => by split_ifs with ha <;> simp only [ite_self, tsum_zero, eq_self_iff_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
⊢ (∑' (x : β), if x ∈ s then ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h) x else 0) =
    ∑' (a : α), p a * if h : p a = 0 then 0 else ∑' (x : β), if x ∈ s then (f a ⋯) x else 0
state_after: no goals

tactic: split_ifs with hbs <;> simp only [eq_self_iff_true, tsum_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
b : β
⊢ (if b ∈ s then ∑' (a : α), p a * if h : p a = 0 then 0 else (f a h) b else 0) =
    ∑' (a : α), if b ∈ s then p a * if h : p a = 0 then 0 else (f a h) b else 0
state_after: no goals

tactic: simp only [← ENNReal.tsum_mul_left, mul_ite, mul_zero]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
a : α
⊢ (∑' (b : β), if b ∈ s then p a * if h : p a = 0 then 0 else (f a h) b else 0) =
    p a * ∑' (b : β), if b ∈ s then if h : p a = 0 then 0 else (f a h) b else 0
state_after: no goals

tactic: split_ifs with ha <;> simp only [ite_self, tsum_zero, eq_self_iff_true]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p : PMF α
f : (a : α) → a ∈ p.support → PMF β
s : Set β
a : α
⊢ (p a * ∑' (b : β), if b ∈ s then if h : p a = 0 then 0 else (f a h) b else 0) =
    p a * if h : p a = 0 then 0 else ∑' (b : β), if b ∈ s then (f a h) b else 0
state_after: no goals
Theorem: Order.succ_lt_succ_iff_of_not_isMax
File: Mathlib/Order/SuccPred/Basic.lean

tactic: rw [lt_succ_iff_of_not_isMax hb, succ_le_iff_of_not_isMax ha]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : Preorder α
inst✝ : SuccOrder α
a b : α
ha : ¬IsMax a
hb : ¬IsMax b
⊢ succ a < succ b ↔ a < b
state_after: no goals
Theorem: List.range'_sublist_right
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

tactic: simpa only [length_range'] using h.length_le
state_before: step s m n : Nat
h : range' s m step <+ range' s n step
⊢ m ≤ n
state_after: no goals

tactic: rw [← Nat.sub_add_cancel h, ← range'_append]
state_before: step s m n : Nat
h : m ≤ n
⊢ range' s m step <+ range' s n step
state_after: step s m n : Nat
h : m ≤ n
⊢ range' s m step <+ range' s m step ++ range' (s + step * m) (n - m) step

tactic: apply sublist_append_left
state_before: step s m n : Nat
h : m ≤ n
⊢ range' s m step <+ range' s m step ++ range' (s + step * m) (n - m) step
state_after: no goals
Theorem: Real.log_mul_self_monotoneOn
File: Mathlib/Analysis/SpecialFunctions/Log/Monotone.lean

tactic: simp only [MonotoneOn, mem_setOf_eq]
state_before: x y : ℝ
⊢ MonotoneOn (fun x => log x * x) {x | 1 ≤ x}
state_after: x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, 1 ≤ a → ∀ ⦃b : ℝ⦄, 1 ≤ b → a ≤ b → log a * a ≤ log b * b

tactic: intro x hex y hey hxy
state_before: x y : ℝ
⊢ ∀ ⦃a : ℝ⦄, 1 ≤ a → ∀ ⦃b : ℝ⦄, 1 ≤ b → a ≤ b → log a * a ≤ log b * b
state_after: x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
⊢ log x * x ≤ log y * y

tactic: have y_pos : 0 < y := lt_of_lt_of_le zero_lt_one hey
state_before: x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
⊢ log x * x ≤ log y * y
state_after: x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
y_pos : 0 < y
⊢ log x * x ≤ log y * y

tactic: gcongr
state_before: x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
y_pos : 0 < y
⊢ log x * x ≤ log y * y
state_after: case b0
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
y_pos : 0 < y
⊢ 0 ≤ log y

tactic: rwa [le_log_iff_exp_le y_pos, Real.exp_zero]
state_before: case b0
x✝ y✝ x : ℝ
hex : 1 ≤ x
y : ℝ
hey : 1 ≤ y
hxy : x ≤ y
y_pos : 0 < y
⊢ 0 ≤ log y
state_after: no goals
Theorem: Tropical.succ_nsmul
File: Mathlib/Algebra/Tropical/Basic.lean

tactic: induction' n with n IH
state_before: R✝ : Type u
inst✝² : LinearOrderedAddCommMonoidWithTop R✝
R : Type u_1
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
x : Tropical R
n : ℕ
⊢ (n + 1) • x = x
state_after: case zero
R✝ : Type u
inst✝² : LinearOrderedAddCommMonoidWithTop R✝
R : Type u_1
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
x : Tropical R
⊢ (0 + 1) • x = x

case succ
R✝ : Type u
inst✝² : LinearOrderedAddCommMonoidWithTop R✝
R : Type u_1
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
x : Tropical R
n : ℕ
IH : (n + 1) • x = x
⊢ (n + 1 + 1) • x = x

tactic: simp
state_before: case zero
R✝ : Type u
inst✝² : LinearOrderedAddCommMonoidWithTop R✝
R : Type u_1
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
x : Tropical R
⊢ (0 + 1) • x = x
state_after: no goals

tactic: rw [add_nsmul, IH, one_nsmul, add_self]
state_before: case succ
R✝ : Type u
inst✝² : LinearOrderedAddCommMonoidWithTop R✝
R : Type u_1
inst✝¹ : LinearOrder R
inst✝ : OrderTop R
x : Tropical R
n : ℕ
IH : (n + 1) • x = x
⊢ (n + 1 + 1) • x = x
state_after: no goals
Theorem: and_symm_left
File: Mathlib/Logic/Basic.lean

tactic: simp [eq_comm]
state_before: a✝ b✝ : Prop
α : Sort u_1
a b : α
p : Prop
⊢ a = b ∧ p ↔ b = a ∧ p
state_after: no goals
Theorem: Nat.Primrec'.tail
File: Mathlib/Computability/Primrec.lean

tactic: rw [← ofFn_get v.tail]
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f v.tail
state_after: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)

tactic: congr
state_before: n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
⊢ f (ofFn fun i => v.get i.succ) = f (ofFn v.tail.get)
state_after: case e_a.e_a
n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get

tactic: funext i
state_before: case e_a.e_a
n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
⊢ (fun i => v.get i.succ) = v.tail.get
state_after: case e_a.e_a.h
n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i

tactic: simp
state_before: case e_a.e_a.h
n : ℕ
f : Vector ℕ n → ℕ
hf : Primrec' f
v : Vector ℕ n.succ
i : Fin n
⊢ v.get i.succ = v.tail.get i
state_after: no goals
Theorem: List.singleton_eq_rotate_iff
File: Mathlib/Data/List/Rotate.lean

tactic: rw [eq_comm, rotate_eq_singleton_iff, eq_comm]
state_before: α : Type u
l : List α
n : ℕ
x : α
⊢ [x] = l.rotate n ↔ [x] = l
state_after: no goals
Theorem: Stream'.WSeq.dropn_congr
File: Mathlib/Data/Seq/WSeq.lean

tactic: induction n <;> simp [*, tail_congr, drop]
state_before: α : Type u
β : Type v
γ : Type w
s t : WSeq α
h : s ~ʷ t
n : ℕ
⊢ s.drop n ~ʷ t.drop n
state_after: no goals
Theorem: isNoetherian_of_submodule_of_noetherian
File: Mathlib/RingTheory/Noetherian.lean

tactic: rw [isNoetherian_iff_wellFounded] at h ⊢
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
h : IsNoetherian R M
⊢ IsNoetherian R ↥N
state_after: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
h : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun x x_1 => x > x_1

tactic: exact OrderEmbedding.wellFounded (Submodule.MapSubtype.orderEmbedding N).dual h
state_before: R : Type u_1
M : Type u_2
inst✝² : Semiring R
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
N : Submodule R M
h : WellFounded fun x x_1 => x > x_1
⊢ WellFounded fun x x_1 => x > x_1
state_after: no goals
Theorem: LieSubmodule.inf_lie
File: Mathlib/Algebra/Lie/IdealOperations.lean

tactic: rw [le_inf_iff]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ⊓ ⁅J, N⁆
state_after: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ∧ ⁅I ⊓ J, N⁆ ≤ ⁅J, N⁆

tactic: constructor <;>
apply mono_lie_left <;> [exact inf_le_left; exact inf_le_right]
state_before: R : Type u
L : Type v
M : Type w
M₂ : Type w₁
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M₂
inst✝² : Module R M₂
inst✝¹ : LieRingModule L M₂
inst✝ : LieModule R L M₂
N N' : LieSubmodule R L M
I J : LieIdeal R L
N₂ : LieSubmodule R L M₂
⊢ ⁅I ⊓ J, N⁆ ≤ ⁅I, N⁆ ∧ ⁅I ⊓ J, N⁆ ≤ ⁅J, N⁆
state_after: no goals
Theorem: isPreirreducible_iff_subsingleton
File: Mathlib/Topology/Separation.lean

tactic: refine ⟨fun h x hx y hy => ?_, Set.Subsingleton.isPreirreducible⟩
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
⊢ IsPreirreducible S ↔ S.Subsingleton
state_after: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
⊢ x = y

tactic: by_contra e
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
⊢ x = y
state_after: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
e : ¬x = y
⊢ False

tactic: obtain ⟨U, V, hU, hV, hxU, hyV, h'⟩ := t2_separation e
state_before: X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
e : ¬x = y
⊢ False
state_after: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
e : ¬x = y
U V : Set X
hU : IsOpen U
hV : IsOpen V
hxU : x ∈ U
hyV : y ∈ V
h' : Disjoint U V
⊢ False

tactic: exact ((h U V hU hV ⟨x, hx, hxU⟩ ⟨y, hy, hyV⟩).mono inter_subset_right).not_disjoint h'
state_before: case intro.intro.intro.intro.intro.intro
X : Type u_1
Y : Type u_2
inst✝⁴ : TopologicalSpace X
inst✝³ : FirstCountableTopology X
Z : Type u_3
inst✝² : TopologicalSpace Y
inst✝¹ : TopologicalSpace Z
inst✝ : T2Space X
S : Set X
h : IsPreirreducible S
x : X
hx : x ∈ S
y : X
hy : y ∈ S
e : ¬x = y
U V : Set X
hU : IsOpen U
hV : IsOpen V
hxU : x ∈ U
hyV : y ∈ V
h' : Disjoint U V
⊢ False
state_after: no goals