1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: ENNReal.zero_rpow_mul_self
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

tactic: rw [zero_rpow_def]
state_before: y : ℝ
⊢ 0 ^ y * 0 ^ y = 0 ^ y
state_after: y : ℝ
⊢ ((if 0 < y then 0 else if y = 0 then 1 else ⊤) * if 0 < y then 0 else if y = 0 then 1 else ⊤) =
    if 0 < y then 0 else if y = 0 then 1 else ⊤

tactic: split_ifs
state_before: y : ℝ
⊢ ((if 0 < y then 0 else if y = 0 then 1 else ⊤) * if 0 < y then 0 else if y = 0 then 1 else ⊤) =
    if 0 < y then 0 else if y = 0 then 1 else ⊤
state_after: case pos
y : ℝ
h✝ : 0 < y
⊢ 0 * 0 = 0

case pos
y : ℝ
h✝¹ : ¬0 < y
h✝ : y = 0
⊢ 1 * 1 = 1

case neg
y : ℝ
h✝¹ : ¬0 < y
h✝ : ¬y = 0
⊢ ⊤ * ⊤ = ⊤

tactic: exacts [zero_mul _, one_mul _, top_mul_top]
state_before: case pos
y : ℝ
h✝ : 0 < y
⊢ 0 * 0 = 0

case pos
y : ℝ
h✝¹ : ¬0 < y
h✝ : y = 0
⊢ 1 * 1 = 1

case neg
y : ℝ
h✝¹ : ¬0 < y
h✝ : ¬y = 0
⊢ ⊤ * ⊤ = ⊤
state_after: no goals
Theorem: MeasureTheory.aestronglyMeasurable_zero_measure
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Basic.lean

tactic: nontriviality α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
⊢ AEStronglyMeasurable f 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
a✝ : Nontrivial α
⊢ AEStronglyMeasurable f 0

tactic: inhabit α
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
a✝ : Nontrivial α
⊢ AEStronglyMeasurable f 0
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEStronglyMeasurable f 0

tactic: exact ⟨fun _ => f default, stronglyMeasurable_const, rfl⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Type u_4
inst✝² : Countable ι
inst✝¹ : MeasurableSpace α
inst✝ : TopologicalSpace β
f : α → β
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ AEStronglyMeasurable f 0
state_after: no goals
Theorem: ZNum.zero_add
File: Mathlib/Data/Num/Lemmas.lean

tactic: cases n <;> rfl
state_before: α : Type u_1
n : ZNum
⊢ 0 + n = n
state_after: no goals
Theorem: String.prev_of_valid'
File: .lake/packages/batteries/Batteries/Data/String/Lemmas.lean

tactic: match cs, cs.eq_nil_or_concat with
| _, .inl rfl => rfl
| _, .inr ⟨cs, c, rfl⟩ => simp [prev_of_valid]
state_before: cs cs' : List Char
⊢ { data := cs ++ cs' }.prev { byteIdx := utf8Len cs } = { byteIdx := utf8Len cs.dropLast }
state_after: no goals

tactic: rfl
state_before: cs cs' : List Char
⊢ { data := [] ++ cs' }.prev { byteIdx := utf8Len [] } = { byteIdx := utf8Len [].dropLast }
state_after: no goals

tactic: simp [prev_of_valid]
state_before: cs✝ cs' cs : List Char
c : Char
⊢ { data := cs.concat c ++ cs' }.prev { byteIdx := utf8Len (cs.concat c) } =
    { byteIdx := utf8Len (cs.concat c).dropLast }
state_after: no goals
Theorem: SemidirectProduct.hom_ext
File: Mathlib/GroupTheory/SemidirectProduct.lean

tactic: rw [lift_unique f, lift_unique g]
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ f = g
state_after: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ lift (f.comp inl) (f.comp inr) ⋯ = lift (g.comp inl) (g.comp inr) ⋯

tactic: simp only [*]
state_before: N : Type u_1
G : Type u_2
H : Type u_3
inst✝² : Group N
inst✝¹ : Group G
inst✝ : Group H
φ : G →* MulAut N
f₁ : N →* H
f₂ : G →* H
h : ∀ (g : G), f₁.comp (MulEquiv.toMonoidHom (φ g)) = (MulEquiv.toMonoidHom (MulAut.conj (f₂ g))).comp f₁
f g : N ⋊[φ] G →* H
hl : f.comp inl = g.comp inl
hr : f.comp inr = g.comp inr
⊢ lift (f.comp inl) (f.comp inr) ⋯ = lift (g.comp inl) (g.comp inr) ⋯
state_after: no goals
Theorem: NNRat.div_def
File: Mathlib/Algebra/Order/Field/Rat.lean

tactic: ext
state_before: p q : ℚ≥0
⊢ p / q = divNat (p.num * q.den) (p.den * q.num)
state_after: case a
p q : ℚ≥0
⊢ ↑(p / q) = ↑(divNat (p.num * q.den) (p.den * q.num))

tactic: simp [Rat.div_def', num_coe, den_coe]
state_before: case a
p q : ℚ≥0
⊢ ↑(p / q) = ↑(divNat (p.num * q.den) (p.den * q.num))
state_after: no goals
Theorem: Mathlib.Tactic.Ring.mul_pf_left
File: Mathlib/Tactic/Ring/Basic.lean

tactic: subst_vars
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₃ b c a₁ : R
a₂ : ℕ
x✝ : a₃ * b = c
⊢ a₁ ^ a₂ * a₃ * b = a₁ ^ a₂ * c
state_after: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₃ b a₁ : R
a₂ : ℕ
⊢ a₁ ^ a₂ * a₃ * b = a₁ ^ a₂ * (a₃ * b)

tactic: rw [mul_assoc]
state_before: u : Lean.Level
R : Type u_1
α : Q(Type u)
sα : Q(CommSemiring «$α»)
inst✝ : CommSemiring R
a₃ b a₁ : R
a₂ : ℕ
⊢ a₁ ^ a₂ * a₃ * b = a₁ ^ a₂ * (a₃ * b)
state_after: no goals
Theorem: MvPolynomial.vars_map_of_injective
File: Mathlib/Algebra/MvPolynomial/Variables.lean

tactic: simp [vars, degrees_map_of_injective _ hf]
state_before: R : Type u
S : Type v
σ : Type u_1
τ : Type u_2
r : R
e : ℕ
n m : σ
s : σ →₀ ℕ
inst✝¹ : CommSemiring R
p q : MvPolynomial σ R
inst✝ : CommSemiring S
f : R →+* S
hf : Injective ⇑f
⊢ ((map f) p).vars = p.vars
state_after: no goals
Theorem: Prefunctor.IsCovering.map_injective
File: Mathlib/Combinatorics/Quiver/Covering.lean

tactic: rintro f g he
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
⊢ Injective fun f => φ.map f
state_after: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
f g : u ⟶ v
he : (fun f => φ.map f) f = (fun f => φ.map f) g
⊢ f = g

tactic: have : φ.star u (Quiver.Star.mk f) = φ.star u (Quiver.Star.mk g) := by simpa using he
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
f g : u ⟶ v
he : (fun f => φ.map f) f = (fun f => φ.map f) g
⊢ f = g
state_after: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
f g : u ⟶ v
he : (fun f => φ.map f) f = (fun f => φ.map f) g
this : φ.star u (Star.mk f) = φ.star u (Star.mk g)
⊢ f = g

tactic: simpa using (hφ.star_bijective u).left this
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
f g : u ⟶ v
he : (fun f => φ.map f) f = (fun f => φ.map f) g
this : φ.star u (Star.mk f) = φ.star u (Star.mk g)
⊢ f = g
state_after: no goals

tactic: simpa using he
state_before: U : Type u_1
inst✝² : Quiver U
V : Type u_2
inst✝¹ : Quiver V
φ : U ⥤q V
W : Type ?u.1962
inst✝ : Quiver W
ψ : V ⥤q W
hφ : φ.IsCovering
u v : U
f g : u ⟶ v
he : (fun f => φ.map f) f = (fun f => φ.map f) g
⊢ φ.star u (Star.mk f) = φ.star u (Star.mk g)
state_after: no goals
Theorem: Part.Fix.le_f_of_mem_approx
File: Mathlib/Control/LawfulFix.lean

tactic: rintro i rfl
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
x : (a : α) → Part (β a)
⊢ ∀ (x_1 : ℕ), x = (approxChain f) x_1 → x ≤ f x
state_after: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
⊢ (approxChain f) i ≤ f ((approxChain f) i)

tactic: apply approx_mono'
state_before: α : Type u_1
β : α → Type u_2
f : ((a : α) → Part (β a)) →o (a : α) → Part (β a)
i : ℕ
⊢ (approxChain f) i ≤ f ((approxChain f) i)
state_after: no goals
Theorem: Mathlib.Tactic.Abel.subst_into_addg
File: Mathlib/Tactic/Abel.lean

tactic: rw [prl, prr, prt]
state_before: α : Type u_1
inst✝ : AddCommGroup α
l r tl tr t : α
prl : l = tl
prr : r = tr
prt : tl + tr = t
⊢ l + r = t
state_after: no goals
Theorem: Function.minimalPeriod_fst_dvd
File: Mathlib/Dynamics/PeriodicPts.lean

tactic: rw [minimalPeriod_prod_map]
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ minimalPeriod (Prod.map f g) x
state_after: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)

tactic: exact Nat.dvd_lcm_left _ _
state_before: α : Type u_1
β : Type u_2
f : α → α
g : β → β
x : α × β
a : α
b : β
m n : ℕ
⊢ minimalPeriod f x.1 ∣ (minimalPeriod f x.1).lcm (minimalPeriod g x.2)
state_after: no goals
Theorem: StieltjesFunction.length_Ioc
File: Mathlib/MeasureTheory/Measure/Stieltjes.lean

tactic: refine
  le_antisymm (iInf_le_of_le a <| iInf₂_le b Subset.rfl)
    (le_iInf fun a' => le_iInf fun b' => le_iInf fun h => ENNReal.coe_le_coe.2 ?_)
state_before: f : StieltjesFunction
a b : ℝ
⊢ f.length (Ioc a b) = ofReal (↑f b - ↑f a)
state_after: f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal

tactic: rcases le_or_lt b a with ab | ab
state_before: f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal
state_after: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal

case inr
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal

tactic: cases' (Ioc_subset_Ioc_iff ab).1 h with h₁ h₂
state_before: case inr
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal
state_after: case inr.intro
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
h₁ : b ≤ b'
h₂ : a' ≤ a
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal

tactic: exact Real.toNNReal_le_toNNReal (sub_le_sub (f.mono h₁) (f.mono h₂))
state_before: case inr.intro
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : a < b
h₁ : b ≤ b'
h₂ : a' ≤ a
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal
state_after: no goals

tactic: rw [Real.toNNReal_of_nonpos (sub_nonpos.2 (f.mono ab))]
state_before: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ (↑f b - ↑f a).toNNReal ≤ (↑f b' - ↑f a').toNNReal
state_after: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ 0 ≤ (↑f b' - ↑f a').toNNReal

tactic: apply zero_le
state_before: case inl
f : StieltjesFunction
a b a' b' : ℝ
h : Ioc a b ⊆ Ioc a' b'
ab : b ≤ a
⊢ 0 ≤ (↑f b' - ↑f a').toNNReal
state_after: no goals
Theorem: Int.dvd_div_of_mul_dvd
File: Mathlib/Data/Int/Defs.lean

tactic: obtain rfl | ha := eq_or_ne a 0
state_before: a b c d m n : ℤ
h : a * b ∣ c
⊢ b ∣ c / a
state_after: case inl
b c d m n : ℤ
h : 0 * b ∣ c
⊢ b ∣ c / 0

case inr
a b c d m n : ℤ
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a

tactic: simp
state_before: case inl
b c d m n : ℤ
h : 0 * b ∣ c
⊢ b ∣ c / 0
state_after: no goals

tactic: obtain ⟨d, rfl⟩ := h
state_before: case inr
a b c d m n : ℤ
h : a * b ∣ c
ha : a ≠ 0
⊢ b ∣ c / a
state_after: case inr.intro
a b d✝ m n : ℤ
ha : a ≠ 0
d : ℤ
⊢ b ∣ a * b * d / a

tactic: simp [Int.mul_assoc, ha]
state_before: case inr.intro
a b d✝ m n : ℤ
ha : a ≠ 0
d : ℤ
⊢ b ∣ a * b * d / a
state_after: no goals
Theorem: Set.einfsep_lt_iff
File: Mathlib/Topology/MetricSpace/Infsep.lean

tactic: simp_rw [einfsep, iInf_lt_iff, exists_prop]
state_before: α : Type u_1
β : Type u_2
inst✝ : EDist α
x y : α
s t : Set α
d : ℝ≥0∞
⊢ s.einfsep < d ↔ ∃ x ∈ s, ∃ y ∈ s, x ≠ y ∧ edist x y < d
state_after: no goals
Theorem: Function.IsFixedPt.birkhoffAverage_eq
File: Mathlib/Dynamics/BirkhoffSum/Average.lean

tactic: rw [birkhoffAverage, h.birkhoffSum_eq, nsmul_eq_smul_cast R, inv_smul_smul₀]
state_before: R : Type u_1
α : Type u_2
M : Type u_3
inst✝³ : DivisionSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : CharZero R
f : α → α
x : α
h : IsFixedPt f x
g : α → M
n : ℕ
hn : n ≠ 0
⊢ birkhoffAverage R f g n x = g x
state_after: case hc
R : Type u_1
α : Type u_2
M : Type u_3
inst✝³ : DivisionSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : CharZero R
f : α → α
x : α
h : IsFixedPt f x
g : α → M
n : ℕ
hn : n ≠ 0
⊢ ↑n ≠ 0

tactic: rwa [Nat.cast_ne_zero]
state_before: case hc
R : Type u_1
α : Type u_2
M : Type u_3
inst✝³ : DivisionSemiring R
inst✝² : AddCommMonoid M
inst✝¹ : Module R M
inst✝ : CharZero R
f : α → α
x : α
h : IsFixedPt f x
g : α → M
n : ℕ
hn : n ≠ 0
⊢ ↑n ≠ 0
state_after: no goals
Theorem: MvPolynomial.pderiv_pow
File: Mathlib/Algebra/MvPolynomial/PDeriv.lean

tactic: rw [(pderiv i).leibniz_pow f n, nsmul_eq_mul, smul_eq_mul, mul_assoc]
state_before: R : Type u
σ : Type v
a a' a₁ a₂ : R
s : σ →₀ ℕ
inst✝ : CommSemiring R
i : σ
f : MvPolynomial σ R
n : ℕ
⊢ (pderiv i) (f ^ n) = ↑n * f ^ (n - 1) * (pderiv i) f
state_after: no goals
Theorem: padicNormE.norm_p
File: Mathlib/NumberTheory/Padics/PadicNumbers.lean

tactic: rw [← @Rat.cast_natCast ℝ _ p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ = (↑p)⁻¹
state_after: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ = (↑↑p)⁻¹

tactic: rw [← @Rat.cast_natCast ℚ_[p] _ p]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑p‖ = (↑↑p)⁻¹
state_after: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑↑p‖ = (↑↑p)⁻¹

tactic: simp [hp.1.ne_zero, hp.1.ne_one, norm, padicNorm, padicValRat, padicValInt, zpow_neg,
  -Rat.cast_natCast]
state_before: p : ℕ
hp : Fact (Nat.Prime p)
⊢ ‖↑↑p‖ = (↑↑p)⁻¹
state_after: no goals
Theorem: List.getElem_rotate
File: Mathlib/Data/List/Rotate.lean

tactic: rw [← Option.some_inj, ← getElem?_eq_getElem, ← getElem?_eq_getElem, getElem?_rotate]
state_before: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ (l.rotate n)[k] = l[(k + n) % l.length]
state_after: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ k < l.length

tactic: exact h.trans_eq (length_rotate _ _)
state_before: α : Type u
l : List α
n k : ℕ
h : k < (l.rotate n).length
⊢ k < l.length
state_after: no goals
Theorem: CategoryTheory.Limits.terminal.comp_from
File: Mathlib/CategoryTheory/Limits/Shapes/Terminal.lean

tactic: simp [eq_iff_true_of_subsingleton]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
inst✝ : HasTerminal C
P Q : C
f : P ⟶ Q
⊢ f ≫ from Q = from P
state_after: no goals
Theorem: Topology.IsLowerSet.closure_singleton
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

tactic: rw [closure_eq_upperClosure, upperClosure_singleton]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : Topology.IsLowerSet α
s : Set α
a : α
⊢ closure {a} = Ici a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : Topology.IsLowerSet α
s : Set α
a : α
⊢ ↑(UpperSet.Ici a) = Ici a

tactic: rfl
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : Topology.IsLowerSet α
s : Set α
a : α
⊢ ↑(UpperSet.Ici a) = Ici a
state_after: no goals
Theorem: ContinuousMap.ideal_isMaximal_iff
File: Mathlib/Topology/ContinuousFunction/Ideals.lean

tactic: refine
  ⟨?_, fun h =>
    let ⟨x, hx⟩ := h
    hx ▸ idealOf_compl_singleton_isMaximal 𝕜 x⟩
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal ↔ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal → ∃ x, idealOfSet 𝕜 {x}ᶜ = I

tactic: intro hI'
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
⊢ I.IsMaximal → ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I

tactic: obtain ⟨x, hx⟩ := setOfIdeal_eq_compl_singleton I
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: case intro
X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
x : X
hx : setOfIdeal I = {x}ᶜ
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I

tactic: exact
  ⟨x, by
    simpa only [idealOfSet_ofIdeal_eq_closure, I.closure_eq_of_isClosed hI] using
      congr_arg (idealOfSet 𝕜) hx.symm⟩
state_before: case intro
X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
x : X
hx : setOfIdeal I = {x}ᶜ
⊢ ∃ x, idealOfSet 𝕜 {x}ᶜ = I
state_after: no goals

tactic: simpa only [idealOfSet_ofIdeal_eq_closure, I.closure_eq_of_isClosed hI] using
  congr_arg (idealOfSet 𝕜) hx.symm
state_before: X : Type u_1
𝕜 : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : TopologicalSpace X
inst✝¹ : CompactSpace X
inst✝ : T2Space X
I : Ideal C(X, 𝕜)
hI : IsClosed ↑I
hI' : I.IsMaximal
x : X
hx : setOfIdeal I = {x}ᶜ
⊢ idealOfSet 𝕜 {x}ᶜ = I
state_after: no goals
Theorem: Matroid.not_dep_iff
File: Mathlib/Data/Matroid/Basic.lean

tactic: rw [Dep, and_iff_left hX, not_not]
state_before: α : Type u_1
M : Matroid α
X : Set α
hX : autoParam (X ⊆ M.E) _auto✝
⊢ ¬M.Dep X ↔ M.Indep X
state_after: no goals
Theorem: Batteries.PairingHeapImp.Heap.size_deleteMin
File: .lake/packages/batteries/Batteries/Data/PairingHeap.lean

tactic: cases h with cases eq | node a c => rw [size_combine, size, size]
state_before: α : Type u_1
le : α → α → Bool
a : α
s' s : Heap α
h : s.NoSibling
eq : deleteMin le s = some (a, s')
⊢ s.size = s'.size + 1
state_after: no goals

tactic: rw [size_combine, size, size]
state_before: case node.refl
α : Type u_1
le : α → α → Bool
a : α
c : Heap α
⊢ (node a c nil).size = (combine le c).size + 1
state_after: no goals
Theorem: Batteries.RBNode.find?_some_eq_eq
File: .lake/packages/batteries/Batteries/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [find?]
state_before: α : Type u_1
x : α
cut : α → Ordering
t : RBNode α
⊢ x ∈ find? cut t → cut x = Ordering.eq
state_after: case node
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
⊢ (match cut v✝ with
      | Ordering.lt => find? cut l✝
      | Ordering.gt => find? cut r✝
      | Ordering.eq => some v✝) =
      some x →
    cut x = Ordering.eq

tactic: split <;> try assumption
state_before: case node
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
⊢ (match cut v✝ with
      | Ordering.lt => find? cut l✝
      | Ordering.gt => find? cut r✝
      | Ordering.eq => some v✝) =
      some x →
    cut x = Ordering.eq
state_after: case node.h_3
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ some v✝ = some x → cut x = Ordering.eq

tactic: intro | rfl => assumption
state_before: case node.h_3
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
x✝ : Ordering
heq✝ : cut v✝ = Ordering.eq
⊢ some v✝ = some x → cut x = Ordering.eq
state_after: no goals

tactic: assumption
state_before: case node.h_2
α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
l_ih✝ : x ∈ find? cut l✝ → cut x = Ordering.eq
r_ih✝ : x ∈ find? cut r✝ → cut x = Ordering.eq
x✝ : Ordering
heq✝ : cut v✝ = Ordering.gt
⊢ find? cut r✝ = some x → cut x = Ordering.eq
state_after: no goals

tactic: assumption
state_before: α : Type u_1
x : α
cut : α → Ordering
c✝ : RBColor
l✝ : RBNode α
v✝ : α
r✝ : RBNode α
x✝¹ : Ordering
heq✝ : cut v✝ = Ordering.eq
x✝ : some v✝ = some x
l_ih✝ : v✝ ∈ find? cut l✝ → cut v✝ = Ordering.eq
r_ih✝ : v✝ ∈ find? cut r✝ → cut v✝ = Ordering.eq
⊢ cut v✝ = Ordering.eq
state_after: no goals
Theorem: Submodule.sub_mem_sup
File: Mathlib/Algebra/Module/Submodule/Lattice.lean

tactic: rw [sub_eq_add_neg]
state_before: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S✝
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : Module S✝ M
inst✝⁴ : SMul S✝ R
inst✝³ : IsScalarTower S✝ R M
p q : Submodule R M
R' : Type u_4
M' : Type u_5
inst✝² : Ring R'
inst✝¹ : AddCommGroup M'
inst✝ : Module R' M'
S T : Submodule R' M'
s t : M'
hs : s ∈ S
ht : t ∈ T
⊢ s - t ∈ S ⊔ T
state_after: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S✝
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : Module S✝ M
inst✝⁴ : SMul S✝ R
inst✝³ : IsScalarTower S✝ R M
p q : Submodule R M
R' : Type u_4
M' : Type u_5
inst✝² : Ring R'
inst✝¹ : AddCommGroup M'
inst✝ : Module R' M'
S T : Submodule R' M'
s t : M'
hs : s ∈ S
ht : t ∈ T
⊢ s + -t ∈ S ⊔ T

tactic: exact add_mem_sup hs (neg_mem ht)
state_before: R : Type u_1
S✝ : Type u_2
M : Type u_3
inst✝⁹ : Semiring R
inst✝⁸ : Semiring S✝
inst✝⁷ : AddCommMonoid M
inst✝⁶ : Module R M
inst✝⁵ : Module S✝ M
inst✝⁴ : SMul S✝ R
inst✝³ : IsScalarTower S✝ R M
p q : Submodule R M
R' : Type u_4
M' : Type u_5
inst✝² : Ring R'
inst✝¹ : AddCommGroup M'
inst✝ : Module R' M'
S T : Submodule R' M'
s t : M'
hs : s ∈ S
ht : t ∈ T
⊢ s + -t ∈ S ⊔ T
state_after: no goals
Theorem: Nat.add_modEq_right
File: Mathlib/Data/Nat/ModEq.lean

tactic: rw [ModEq, add_mod_right]
state_before: m n a b c d : ℕ
⊢ a + n ≡ a [MOD n]
state_after: no goals