1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: smul_add_smul_lt_smul_add_smul
File: Mathlib/Algebra/Order/Module/Defs.lean

tactic: obtain ⟨b₂, rfl⟩ := exists_add_of_le hab.le
state_before: α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ b₂ : α
a d : β
hab : b₁ < b₂
hcd : a < d
⊢ b₁ • d + b₂ • a < b₁ • a + b₂ • d
state_after: case intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a d : β
hcd : a < d
b₂ : α
hab : b₁ < b₁ + b₂
⊢ b₁ • d + (b₁ + b₂) • a < b₁ • a + (b₁ + b₂) • d

tactic: obtain ⟨d, rfl⟩ := exists_add_of_le hcd.le
state_before: case intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a d : β
hcd : a < d
b₂ : α
hab : b₁ < b₁ + b₂
⊢ b₁ • d + (b₁ + b₂) • a < b₁ • a + (b₁ + b₂) • d
state_after: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : b₁ < b₁ + b₂
d : β
hcd : a < a + d
⊢ b₁ • (a + d) + (b₁ + b₂) • a < b₁ • a + (b₁ + b₂) • (a + d)

tactic: rw [smul_add, add_right_comm, smul_add, ← add_assoc, add_smul _ _ d]
state_before: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : b₁ < b₁ + b₂
d : β
hcd : a < a + d
⊢ b₁ • (a + d) + (b₁ + b₂) • a < b₁ • a + (b₁ + b₂) • (a + d)
state_after: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : b₁ < b₁ + b₂
d : β
hcd : a < a + d
⊢ b₁ • a + (b₁ + b₂) • a + b₁ • d < b₁ • a + (b₁ + b₂) • a + (b₁ • d + b₂ • d)

tactic: rw [lt_add_iff_pos_right] at hab hcd
state_before: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : b₁ < b₁ + b₂
d : β
hcd : a < a + d
⊢ b₁ • a + (b₁ + b₂) • a + b₁ • d < b₁ • a + (b₁ + b₂) • a + (b₁ • d + b₂ • d)
state_after: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : 0 < b₂
d : β
hcd : 0 < d
⊢ b₁ • a + (b₁ + b₂) • a + b₁ • d < b₁ • a + (b₁ + b₂) • a + (b₁ • d + b₂ • d)

tactic: exact add_lt_add_left (lt_add_of_pos_right _ <| smul_pos hab hcd) _
state_before: case intro.intro
α : Type u_1
β : Type u_2
a✝ a₁ a₂ : α
b b₁✝ b₂✝ : β
inst✝³ : OrderedRing α
inst✝² : OrderedAddCommGroup β
inst✝¹ : Module α β
inst✝ : PosSMulStrictMono α β
b₁ : α
a : β
b₂ : α
hab : 0 < b₂
d : β
hcd : 0 < d
⊢ b₁ • a + (b₁ + b₂) • a + b₁ • d < b₁ • a + (b₁ + b₂) • a + (b₁ • d + b₂ • d)
state_after: no goals
Theorem: LeftOrdContinuous.comp
File: Mathlib/Order/OrdContinuous.lean

tactic: simpa only [image_image] using hg (hf h)
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
inst✝² : Preorder α
inst✝¹ : Preorder β
inst✝ : Preorder γ
g : β → γ
f : α → β
hg : LeftOrdContinuous g
hf : LeftOrdContinuous f
s : Set α
x : α
h : IsLUB s x
⊢ IsLUB (g ∘ f '' s) ((g ∘ f) x)
state_after: no goals
Theorem: Function.apply_update₂
File: Mathlib/Logic/Function/Basic.lean

tactic: by_cases h:j = i
state_before: α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
⊢ f j (update g i v j) (update h i w j) = update (fun k => f k (g k) (h k)) i (f i v w) j
state_after: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j

case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : ¬j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j

tactic: subst j
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j
state_after: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
⊢ f i (update g i v i) (update h i w i) = update (fun k => f k (g k) (h k)) i (f i v w) i

tactic: simp
state_before: case pos
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h : (i : ι) → β i
i : ι
v : α i
w : β i
⊢ f i (update g i v i) (update h i w i) = update (fun k => f k (g k) (h k)) i (f i v w) i
state_after: no goals

tactic: simp [h]
state_before: case neg
α✝ : Sort u
β✝ : α✝ → Sort v
α' : Sort w
inst✝² : DecidableEq α✝
inst✝¹ : DecidableEq α'
f✝ g✝ : (a : α✝) → β✝ a
a : α✝
b : β✝ a
ι : Sort u_1
inst✝ : DecidableEq ι
α : ι → Sort u_2
β : ι → Sort u_3
γ : ι → Sort u_4
f : (i : ι) → α i → β i → γ i
g : (i : ι) → α i
h✝ : (i : ι) → β i
i : ι
v : α i
w : β i
j : ι
h : ¬j = i
⊢ f j (update g i v j) (update h✝ i w j) = update (fun k => f k (g k) (h✝ k)) i (f i v w) j
state_after: no goals
Theorem: Int.shiftRight_neg
File: Mathlib/Data/Int/Bitwise.lean

tactic: rw [← shiftLeft_neg, neg_neg]
state_before: m n : ℤ
⊢ m >>> (-n) = m <<< n
state_after: no goals
Theorem: Real.eulerMascheroniSeq_lt_eulerMascheroniConstant
File: Mathlib/NumberTheory/Harmonic/EulerMascheroni.lean

tactic: refine (strictMono_eulerMascheroniSeq (Nat.lt_succ_self n)).trans_le ?_
state_before: n : ℕ
⊢ eulerMascheroniSeq n < eulerMascheroniConstant
state_after: n : ℕ
⊢ eulerMascheroniSeq n.succ ≤ eulerMascheroniConstant

tactic: apply strictMono_eulerMascheroniSeq.monotone.ge_of_tendsto tendsto_eulerMascheroniSeq
state_before: n : ℕ
⊢ eulerMascheroniSeq n.succ ≤ eulerMascheroniConstant
state_after: no goals
Theorem: multiplicity.multiplicity_pow_self
File: Mathlib/RingTheory/Multiplicity.lean

tactic: rw [eq_coe_iff]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ multiplicity p (p ^ n) = ↑n
state_after: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ p ^ n ∣ p ^ n ∧ ¬p ^ (n + 1) ∣ p ^ n

tactic: use dvd_rfl
state_before: α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ p ^ n ∣ p ^ n ∧ ¬p ^ (n + 1) ∣ p ^ n
state_after: case right
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬p ^ (n + 1) ∣ p ^ n

tactic: rw [pow_dvd_pow_iff h0 hu]
state_before: case right
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬p ^ (n + 1) ∣ p ^ n
state_after: case right
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬n + 1 ≤ n

tactic: apply Nat.not_succ_le_self
state_before: case right
α : Type u_1
β : Type u_2
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : DecidableRel fun x x_1 => x ∣ x_1
p : α
h0 : p ≠ 0
hu : ¬IsUnit p
n : ℕ
⊢ ¬n + 1 ≤ n
state_after: no goals
Theorem: CategoryTheory.Bicategory.triangle_assoc_comp_right
File: Mathlib/CategoryTheory/Bicategory/Basic.lean

tactic: rw [← triangle, inv_hom_id_assoc]
state_before: B : Type u
inst✝ : Bicategory B
a b c d e : B
f : a ⟶ b
g : b ⟶ c
⊢ (α_ f (𝟙 b) g).inv ≫ (ρ_ f).hom ▷ g = f ◁ (λ_ g).hom
state_after: no goals
Theorem: WeierstrassCurve.Jacobian.eval_polynomialY_of_Z_ne_zero
File: Mathlib/AlgebraicGeometry/EllipticCurve/Jacobian.lean

tactic: linear_combination (norm := (rw [eval_polynomialY, Affine.evalEval_polynomialY]; ring1))
  W.a₁ * P x / P z ^ 2 * div_self hPz + W.a₃ * div_self (pow_ne_zero 3 hPz)
state_before: R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (eval P) W.polynomialY / P z ^ 3 = Polynomial.evalEval (P x / P z ^ 2) (P y / P z ^ 3) W.toAffine.polynomialY
state_after: no goals

tactic: rw [eval_polynomialY, Affine.evalEval_polynomialY]
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (eval P) W.polynomialY / P z ^ 3 - Polynomial.evalEval (P x / P z ^ 2) (P y / P z ^ 3) W.toAffine.polynomialY -
      (W.a₁ * P x / P z ^ 2 * (P z / P z) + W.a₃ * (P z ^ 3 / P z ^ 3) - (W.a₁ * P x / P z ^ 2 * 1 + W.a₃ * 1)) =
    0
state_after: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (2 * P y + W.a₁ * P x * P z + W.a₃ * P z ^ 3) / P z ^ 3 -
        (2 * (P y / P z ^ 3) + W.toAffine.a₁ * (P x / P z ^ 2) + W.toAffine.a₃) -
      (W.a₁ * P x / P z ^ 2 * (P z / P z) + W.a₃ * (P z ^ 3 / P z ^ 3) - (W.a₁ * P x / P z ^ 2 * 1 + W.a₃ * 1)) =
    0

tactic: ring1
state_before: case a
R : Type u
inst✝¹ : CommRing R
W' : Jacobian R
F : Type v
inst✝ : Field F
W : Jacobian F
P : Fin 3 → F
hPz : P z ≠ 0
⊢ (2 * P y + W.a₁ * P x * P z + W.a₃ * P z ^ 3) / P z ^ 3 -
        (2 * (P y / P z ^ 3) + W.toAffine.a₁ * (P x / P z ^ 2) + W.toAffine.a₃) -
      (W.a₁ * P x / P z ^ 2 * (P z / P z) + W.a₃ * (P z ^ 3 / P z ^ 3) - (W.a₁ * P x / P z ^ 2 * 1 + W.a₃ * 1)) =
    0
state_after: no goals
Theorem: Set.image_add_const_uIcc
File: Mathlib/Data/Set/Pointwise/Interval.lean

tactic: simp
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
a b c d : α
⊢ (fun x => x + a) '' [[b, c]] = [[b + a, c + a]]
state_after: no goals
Theorem: MvPowerSeries.mul_inv_rev
File: Mathlib/RingTheory/MvPowerSeries/Inverse.lean

tactic: by_cases h : constantCoeff σ k (φ * ψ) = 0
state_before: σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹
state_after: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹

case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹

tactic: rw [inv_eq_zero.mpr h]
state_before: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹
state_after: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) (φ * ψ) = 0
⊢ 0 = ψ⁻¹ * φ⁻¹

tactic: simp only [map_mul, mul_eq_zero] at h
state_before: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) (φ * ψ) = 0
⊢ 0 = ψ⁻¹ * φ⁻¹
state_after: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) φ = 0 ∨ (constantCoeff σ k) ψ = 0
⊢ 0 = ψ⁻¹ * φ⁻¹

tactic: cases' h with h h <;> simp [inv_eq_zero.mpr h]
state_before: case pos
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : (constantCoeff σ k) φ = 0 ∨ (constantCoeff σ k) ψ = 0
⊢ 0 = ψ⁻¹ * φ⁻¹
state_after: no goals

tactic: rw [MvPowerSeries.inv_eq_iff_mul_eq_one h]
state_before: case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) (φ * ψ) = 0
⊢ (φ * ψ)⁻¹ = ψ⁻¹ * φ⁻¹
state_after: case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) (φ * ψ) = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1

tactic: simp only [not_or, map_mul, mul_eq_zero] at h
state_before: case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) (φ * ψ) = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1
state_after: case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) φ = 0 ∧ ¬(constantCoeff σ k) ψ = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1

tactic: rw [← mul_assoc, mul_assoc _⁻¹, MvPowerSeries.inv_mul_cancel _ h.left, mul_one,
  MvPowerSeries.inv_mul_cancel _ h.right]
state_before: case neg
σ : Type u_1
R : Type u_2
k : Type u_3
inst✝ : Field k
φ ψ : MvPowerSeries σ k
h : ¬(constantCoeff σ k) φ = 0 ∧ ¬(constantCoeff σ k) ψ = 0
⊢ ψ⁻¹ * φ⁻¹ * (φ * ψ) = 1
state_after: no goals
Theorem: Homeomorph.comp_isOpenMap_iff
File: Mathlib/Topology/Homeomorph.lean

tactic: refine ⟨?_, fun hf => h.isOpenMap.comp hf⟩
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
⊢ IsOpenMap (⇑h ∘ f) ↔ IsOpenMap f
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
⊢ IsOpenMap (⇑h ∘ f) → IsOpenMap f

tactic: intro hf
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
⊢ IsOpenMap (⇑h ∘ f) → IsOpenMap f
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
hf : IsOpenMap (⇑h ∘ f)
⊢ IsOpenMap f

tactic: rw [← Function.id_comp f, ← h.symm_comp_self, Function.comp.assoc]
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
hf : IsOpenMap (⇑h ∘ f)
⊢ IsOpenMap f
state_after: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
hf : IsOpenMap (⇑h ∘ f)
⊢ IsOpenMap (⇑h.symm ∘ ⇑h ∘ f)

tactic: exact h.symm.isOpenMap.comp hf
state_before: X : Type u_1
Y : Type u_2
Z : Type u_3
inst✝⁴ : TopologicalSpace X
inst✝³ : TopologicalSpace Y
inst✝² : TopologicalSpace Z
X' : Type u_4
Y' : Type u_5
inst✝¹ : TopologicalSpace X'
inst✝ : TopologicalSpace Y'
h : X ≃ₜ Y
f : Z → X
hf : IsOpenMap (⇑h ∘ f)
⊢ IsOpenMap (⇑h.symm ∘ ⇑h ∘ f)
state_after: no goals
Theorem: padicNorm.div
File: Mathlib/NumberTheory/Padics/PadicNorm.lean

tactic: simp [hr]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : r = 0
⊢ padicNorm p (q / r) = padicNorm p q / padicNorm p r
state_after: no goals

tactic: rw [← padicNorm.mul, div_mul_cancel₀ _ hr]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
q r : ℚ
hr : ¬r = 0
⊢ padicNorm p (q / r) * padicNorm p r = padicNorm p q
state_after: no goals
Theorem: HomogeneousLocalization.val_add
File: Mathlib/RingTheory/GradedAlgebra/HomogeneousLocalization.lean

tactic: rw [← mk_add, val_mk, val_mk, val_mk, Localization.add_mk]
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ (Quotient.mk'' y1 + Quotient.mk'' y2).val = val (Quotient.mk'' y1) + val (Quotient.mk'' y2)
state_after: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 + y2).num ⟨↑(y1 + y2).den, ⋯⟩ =
    Localization.mk (↑⟨↑y1.den, ⋯⟩ * ↑y2.num + ↑⟨↑y2.den, ⋯⟩ * ↑y1.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)

tactic: rfl
state_before: ι : Type u_1
R : Type u_2
A : Type u_3
inst✝⁵ : AddCommMonoid ι
inst✝⁴ : DecidableEq ι
inst✝³ : CommRing R
inst✝² : CommRing A
inst✝¹ : Algebra R A
𝒜 : ι → Submodule R A
inst✝ : GradedAlgebra 𝒜
x : Submonoid A
y1 y2 : NumDenSameDeg 𝒜 x
⊢ Localization.mk ↑(y1 + y2).num ⟨↑(y1 + y2).den, ⋯⟩ =
    Localization.mk (↑⟨↑y1.den, ⋯⟩ * ↑y2.num + ↑⟨↑y2.den, ⋯⟩ * ↑y1.num) (⟨↑y1.den, ⋯⟩ * ⟨↑y2.den, ⋯⟩)
state_after: no goals
Theorem: CategoryTheory.Limits.prod_rightUnitor_inv_naturality
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: rw [Iso.inv_comp_eq, ← Category.assoc, Iso.eq_comp_inv, prod.rightUnitor_hom_naturality]
state_before: C : Type u
inst✝² : Category.{v, u} C
X Y : C
inst✝¹ : HasTerminal C
inst✝ : HasBinaryProducts C
f : X ⟶ Y
⊢ (prod.rightUnitor X).inv ≫ prod.map f (𝟙 (⊤_ C)) = f ≫ (prod.rightUnitor Y).inv
state_after: no goals
Theorem: Set.Ioc_union_Ioc_union_Ioc_cycle
File: Mathlib/Order/Interval/Set/Basic.lean

tactic: rw [Ioc_union_Ioc, Ioc_union_Ioc] <;>
simp [min_le_of_left_le, min_le_of_right_le, le_max_of_le_left, le_max_of_le_right, le_refl,
  min_assoc, max_comm]
state_before: α : Type u_1
β : Type u_2
inst✝¹ : LinearOrder α
inst✝ : LinearOrder β
f : α → β
a a₁ a₂ b b₁ b₂ c d : α
⊢ Ioc a b ∪ Ioc b c ∪ Ioc c a = Ioc (min a (min b c)) (max a (max b c))
state_after: no goals
Theorem: hyperoperation_three
File: Mathlib/Data/Nat/Hyperoperation.lean

tactic: ext m k
state_before: ⊢ hyperoperation 3 = fun x x_1 => x ^ x_1
state_after: case h.h
m k : ℕ
⊢ hyperoperation 3 m k = m ^ k

tactic: induction' k with bn bih
state_before: case h.h
m k : ℕ
⊢ hyperoperation 3 m k = m ^ k
state_after: case h.h.zero
m : ℕ
⊢ hyperoperation 3 m 0 = m ^ 0

case h.h.succ
m bn : ℕ
bih : hyperoperation 3 m bn = m ^ bn
⊢ hyperoperation 3 m (bn + 1) = m ^ (bn + 1)

tactic: rw [hyperoperation_ge_three_eq_one]
state_before: case h.h.zero
m : ℕ
⊢ hyperoperation 3 m 0 = m ^ 0
state_after: case h.h.zero
m : ℕ
⊢ 1 = m ^ 0

tactic: exact (pow_zero m).symm
state_before: case h.h.zero
m : ℕ
⊢ 1 = m ^ 0
state_after: no goals

tactic: rw [hyperoperation_recursion, hyperoperation_two, bih]
state_before: case h.h.succ
m bn : ℕ
bih : hyperoperation 3 m bn = m ^ bn
⊢ hyperoperation 3 m (bn + 1) = m ^ (bn + 1)
state_after: case h.h.succ
m bn : ℕ
bih : hyperoperation 3 m bn = m ^ bn
⊢ (fun x x_1 => x * x_1) m (m ^ bn) = m ^ (bn + 1)

tactic: exact (pow_succ' m bn).symm
state_before: case h.h.succ
m bn : ℕ
bih : hyperoperation 3 m bn = m ^ bn
⊢ (fun x x_1 => x * x_1) m (m ^ bn) = m ^ (bn + 1)
state_after: no goals
Theorem: Monoid.exponent_min
File: Mathlib/GroupTheory/Exponent.lean

tactic: by_contra! h
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
⊢ ∃ g, g ^ m ≠ 1
state_after: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
⊢ False

tactic: have hcon : exponent G ≤ m := exponent_min' m hpos h
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
⊢ False
state_after: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
hcon : exponent G ≤ m
⊢ False

tactic: omega
state_before: G : Type u
inst✝ : Monoid G
m : ℕ
hpos : 0 < m
hm : m < exponent G
h : ∀ (g : G), g ^ m = 1
hcon : exponent G ≤ m
⊢ False
state_after: no goals
Theorem: FreeMagma.length_toFreeSemigroup
File: Mathlib/Algebra/Free.lean

tactic: rw [map_mul, FreeSemigroup.length_mul, hx, hy]
state_before: α : Type u
β : Type v
x✝ x y : FreeMagma α
hx : (toFreeSemigroup x).length = x.length
hy : (toFreeSemigroup y).length = y.length
⊢ (toFreeSemigroup (x * y)).length = (x * y).length
state_after: α : Type u
β : Type v
x✝ x y : FreeMagma α
hx : (toFreeSemigroup x).length = x.length
hy : (toFreeSemigroup y).length = y.length
⊢ x.length + y.length = (x * y).length

tactic: rfl
state_before: α : Type u
β : Type v
x✝ x y : FreeMagma α
hx : (toFreeSemigroup x).length = x.length
hy : (toFreeSemigroup y).length = y.length
⊢ x.length + y.length = (x * y).length
state_after: no goals
Theorem: BoxIntegral.TaggedPrepartition.mem_infPrepartition_comm
File: Mathlib/Analysis/BoxIntegral/Partition/Tagged.lean

tactic: simp only [← mem_toPrepartition, infPrepartition_toPrepartition, inf_comm]
state_before: ι : Type u_1
I J : Box ι
π π₁ π₂ : TaggedPrepartition I
x : ι → ℝ
⊢ J ∈ π₁.infPrepartition π₂.toPrepartition ↔ J ∈ π₂.infPrepartition π₁.toPrepartition
state_after: no goals
Theorem: IsCompact.nonempty_sInter_of_directed_nonempty_isCompact_isClosed
File: Mathlib/Topology/Compactness/Compact.lean

tactic: rw [sInter_eq_iInter]
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂₀ S).Nonempty
state_after: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂ i, ↑i).Nonempty

tactic: exact IsCompact.nonempty_iInter_of_directed_nonempty_isCompact_isClosed _
  (DirectedOn.directed_val hSd) (fun i ↦ hSn i i.2) (fun i ↦ hSc i i.2) (fun i ↦ hScl i i.2)
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
S : Set (Set X)
hS : Nonempty ↑S
hSd : DirectedOn (fun x x_1 => x ⊇ x_1) S
hSn : ∀ U ∈ S, U.Nonempty
hSc : ∀ U ∈ S, IsCompact U
hScl : ∀ U ∈ S, IsClosed U
⊢ (⋂ i, ↑i).Nonempty
state_after: no goals
Theorem: MDifferentiableOn.eqOn_of_isPreconnected_of_isMaxOn_norm
File: Mathlib/Geometry/Manifold/Complex.lean

tactic: simp only [H₂, SameRay.rfl.norm_add, H₁, Function.const]
state_before: E : Type u_1
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℂ E
F : Type u_2
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℂ F
H : Type u_3
inst✝⁶ : TopologicalSpace H
I : ModelWithCorners ℂ E H
inst✝⁵ : I.Boundaryless
M : Type u_4
inst✝⁴ : TopologicalSpace M
inst✝³ : CompactSpace M
inst✝² : ChartedSpace H M
inst✝¹ : SmoothManifoldWithCorners I M
inst✝ : StrictConvexSpace ℝ F
f : M → F
U : Set M
c : M
hd : MDifferentiableOn I 𝓘(ℂ, F) f U
hc : IsPreconnected U
ho : IsOpen U
hcU : c ∈ U
hm : IsMaxOn (norm ∘ f) U c
x : M
hx : x ∈ U
H₁ : ‖f x‖ = ‖f c‖
hd' : MDifferentiableOn I 𝓘(ℂ, F) (fun x => f x + f c) U
H₂ : ‖f x + f c‖ = ‖f c + f c‖
⊢ ‖f x + const M (f c) x‖ = ‖f x‖ + ‖const M (f c) x‖
state_after: no goals