ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: RCLike.pos_iff_exists_ofReal
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
⊢ 0 < z ↔ ∃ x > 0, ↑x = z
state_after: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
⊢ 0 < re z ∧ im z = 0 ↔ ∃ x > 0, re ↑x = re z ∧ im ↑x = im z
tactic: simp_rw [pos_iff (K := K), ext_iff (K := K)]
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z w : K
⊢ 0 < re z ∧ im z = 0 ↔ ∃ x > 0, re ↑x = re z ∧ im ↑x = im z
state_after: no goals
tactic: aesop
Theorem: Finset.filter_ne
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
s✝ t : Finset α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b : β
⊢ filter (fun a => b ≠ a) s = s.erase b
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
s✝ t : Finset α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ filter (fun a => b ≠ a) s ↔ a✝ ∈ s.erase b
tactic: ext
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
s✝ t : Finset α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ filter (fun a => b ≠ a) s ↔ a✝ ∈ s.erase b
state_after: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
s✝ t : Finset α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ s ∧ ¬b = a✝ ↔ ¬a✝ = b ∧ a✝ ∈ s
tactic: simp only [mem_filter, mem_erase, Ne, decide_not, Bool.not_eq_true', decide_eq_false_iff_not]
state_before: case a
α : Type u_1
β : Type u_2
γ : Type u_3
p q : α → Prop
inst✝³ : DecidablePred p
inst✝² : DecidablePred q
s✝ t : Finset α
inst✝¹ : DecidableEq α
inst✝ : DecidableEq β
s : Finset β
b a✝ : β
⊢ a✝ ∈ s ∧ ¬b = a✝ ↔ ¬a✝ = b ∧ a✝ ∈ s
state_after: no goals
tactic: tauto
Theorem: Finset.inv_zero
File: Mathlib/Data/Finset/Pointwise.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
⊢ 0⁻¹ = 0
state_after: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
a✝ : α
⊢ a✝ ∈ 0⁻¹ ↔ a✝ ∈ 0
tactic: ext
state_before: case a
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝³ : DecidableEq β
inst✝² : GroupWithZero α
inst✝¹ : MulAction α β
s t : Finset β
a : α
b : β
inst✝ : DecidableEq α
a✝ : α
⊢ a✝ ∈ 0⁻¹ ↔ a✝ ∈ 0
state_after: no goals
tactic: simp
Theorem: AddSubgroup.mem_centralizer_iff_commutator_eq_zero
File: Mathlib/GroupTheory/Subgroup/Centralizer.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
g : G
s : Set G
⊢ g ∈ centralizer s ↔ ∀ h ∈ s, h * g * h⁻¹ * g⁻¹ = 1
state_after: no goals
tactic: simp only [mem_centralizer_iff, mul_inv_eq_iff_eq_mul, one_mul]
Theorem: Cardinal.mk_finsupp_of_fintype
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α✝ β✝ α β : Type u
inst✝¹ : Fintype α
inst✝ : Zero β
⊢ #(α →₀ β) = #β ^ Fintype.card α
state_after: no goals
tactic: simp
Theorem: Real.logb_nonneg_iff_of_base_lt_one
File: Mathlib/Analysis/SpecialFunctions/Log/Base.lean

Proof steps:
state_before: b x y : ℝ
b_pos : 0 < b
b_lt_one : b < 1
hx : 0 < x
⊢ 0 ≤ logb b x ↔ x ≤ 1
state_after: no goals
tactic: rw [← not_lt, logb_neg_iff_of_base_lt_one b_pos b_lt_one hx, not_lt]
Theorem: Finset.prod_mul_eq_prod_mul_of_exists
File: Mathlib/Algebra/BigOperators/Group/Finset.lean

Proof steps:
state_before: ι : Type u_1
κ : Type u_2
α : Type u_3
β : Type u_4
γ : Type u_5
s✝ s₁ s₂ : Finset α
a✝ : α
f✝ g : α → β
inst✝ : CommMonoid β
s : Finset α
f : α → β
b₁ b₂ : β
a : α
ha : a ∈ s
h : f a * b₁ = f a * b₂
⊢ (∏ a ∈ s, f a) * b₁ = (∏ a ∈ s, f a) * b₂
state_after: no goals
tactic: classical
  rw [← insert_erase ha]
  simp only [mem_erase, ne_eq, not_true_eq_false, false_and, not_false_eq_true, prod_insert]
  rw [mul_assoc, mul_comm, mul_assoc, mul_comm b₁, h, ← mul_assoc, mul_comm _ (f a)]
Theorem: Function.extend_inv
File: Mathlib/Algebra/Group/Pi/Basic.lean

Proof steps:
state_before: I : Type u
α : Type u_1
β : Type u_2
γ : Type u_3
f✝ : I → Type v₁
g✝ : I → Type v₂
h : I → Type v₃
x y : (i : I) → f✝ i
i : I
inst✝ : Inv γ
f : α → β
g : α → γ
e : β → γ
⊢ extend f g⁻¹ e⁻¹ = (extend f g e)⁻¹
state_after: no goals
tactic: classical
  funext x
  simp only [not_exists, extend_def, Pi.inv_apply, apply_dite Inv.inv]
Theorem: Set.inv_mem_center
File: Mathlib/Algebra/Group/Center.lean

Proof steps:
state_before: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
⊢ a⁻¹ ∈ center M
state_after: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
⊢ ∀ (g : M), g * a⁻¹ = a⁻¹ * g
tactic: rw [_root_.Semigroup.mem_center_iff]
state_before: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
⊢ ∀ (g : M), g * a⁻¹ = a⁻¹ * g
state_after: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
g✝ : M
⊢ g✝ * a⁻¹ = a⁻¹ * g✝
tactic: intro _
state_before: M : Type u_1
S T : Set M
inst✝ : DivisionMonoid M
a b : M
ha : a ∈ center M
g✝ : M
⊢ g✝ * a⁻¹ = a⁻¹ * g✝
state_after: no goals
tactic: rw [← inv_inj, mul_inv_rev, inv_inv, ha.comm, mul_inv_rev, inv_inv]
Theorem: ENNReal.one_le_inv
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ 1 ≤ a⁻¹ ↔ a ≤ 1
state_after: no goals
tactic: rw [le_inv_iff_le_inv, inv_one]
Theorem: SimpleGraph.IsClique.map
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t : Set α
a b : α
h : G.IsClique s
f : α ↪ β
⊢ (SimpleGraph.map f G).IsClique (⇑f '' s)
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t : Set α
a✝ b✝ : α
h : G.IsClique s
f : α ↪ β
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : f a ≠ f b
⊢ (SimpleGraph.map f G).Adj (f a) (f b)
tactic: rintro _ ⟨a, ha, rfl⟩ _ ⟨b, hb, rfl⟩ hab
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
G H : SimpleGraph α
s t : Set α
a✝ b✝ : α
h : G.IsClique s
f : α ↪ β
a : α
ha : a ∈ s
b : α
hb : b ∈ s
hab : f a ≠ f b
⊢ (SimpleGraph.map f G).Adj (f a) (f b)
state_after: no goals
tactic: exact ⟨a, b, h ha hb <| ne_of_apply_ne _ hab, rfl, rfl⟩
Theorem: mul_star_self_pos
File: Mathlib/Algebra/Star/Order.lean

Proof steps:
state_before: R : Type u
inst✝⁴ : NonUnitalSemiring R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : Nontrivial R
x : R
hx : IsRegular x
⊢ 0 < x * star x
state_after: no goals
tactic: simpa using star_mul_self_pos hx.star
Theorem: FormalMultilinearSeries.order_eq_zero_iff
File: Mathlib/Analysis/Calculus/FormalMultilinearSeries.lean

Proof steps:
state_before: 𝕜 : Type u
𝕜' : Type u'
E : Type v
F : Type w
G : Type x
inst✝¹⁰ : Ring 𝕜
n : ℕ
inst✝⁹ : AddCommGroup E
inst✝⁸ : Module 𝕜 E
inst✝⁷ : TopologicalSpace E
inst✝⁶ : TopologicalAddGroup E
inst✝⁵ : ContinuousConstSMul 𝕜 E
inst✝⁴ : AddCommGroup F
inst✝³ : Module 𝕜 F
inst✝² : TopologicalSpace F
inst✝¹ : TopologicalAddGroup F
inst✝ : ContinuousConstSMul 𝕜 F
p : FormalMultilinearSeries 𝕜 E F
hp : p ≠ 0
⊢ p.order = 0 ↔ p 0 ≠ 0
state_after: no goals
tactic: simp [order_eq_zero_iff', hp]
Theorem: CategoryTheory.Limits.cospanExt_inv_app_right
File: Mathlib/CategoryTheory/Limits/Shapes/Pullback/Cospan.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X Y Z X' Y' Z' : C
iX : X ≅ X'
iY : Y ≅ Y'
iZ : Z ≅ Z'
f : X ⟶ Z
g : Y ⟶ Z
f' : X' ⟶ Z'
g' : Y' ⟶ Z'
wf : iX.hom ≫ f' = f ≫ iZ.hom
wg : iY.hom ≫ g' = g ≫ iZ.hom
⊢ (cospanExt iX iY iZ wf wg).inv.app WalkingCospan.right = iY.inv
state_after: no goals
tactic: dsimp [cospanExt]
Theorem: AlgebraicGeometry.Scheme.OpenCover.hom_ext
File: Mathlib/AlgebraicGeometry/Gluing.lean

Proof steps:
state_before: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
⊢ f₁ = f₂
state_after: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
⊢ 𝒰.fromGlued ≫ f₁ = 𝒰.fromGlued ≫ f₂
tactic: rw [← cancel_epi 𝒰.fromGlued]
state_before: X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
⊢ 𝒰.fromGlued ≫ f₁ = 𝒰.fromGlued ≫ f₂
state_after: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
⊢ ∀ (b : 𝒰.gluedCover.diagram.R),
    Multicoequalizer.π 𝒰.gluedCover.diagram b ≫ 𝒰.fromGlued ≫ f₁ =
      Multicoequalizer.π 𝒰.gluedCover.diagram b ≫ 𝒰.fromGlued ≫ f₂
tactic: apply Multicoequalizer.hom_ext
state_before: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
⊢ ∀ (b : 𝒰.gluedCover.diagram.R),
    Multicoequalizer.π 𝒰.gluedCover.diagram b ≫ 𝒰.fromGlued ≫ f₁ =
      Multicoequalizer.π 𝒰.gluedCover.diagram b ≫ 𝒰.fromGlued ≫ f₂
state_after: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₁ =
    Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₂
tactic: intro x
state_before: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₁ =
    Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₂
state_after: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ 𝒰.map x ≫ f₁ = Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₂
tactic: erw [Multicoequalizer.π_desc_assoc]
state_before: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ 𝒰.map x ≫ f₁ = Multicoequalizer.π 𝒰.gluedCover.diagram x ≫ 𝒰.fromGlued ≫ f₂
state_after: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
tactic: erw [Multicoequalizer.π_desc_assoc]
state_before: case h
X : Scheme
𝒰 : X.OpenCover
Y : Scheme
f₁ f₂ : X ⟶ Y
h : ∀ (x : 𝒰.J), 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
x : 𝒰.gluedCover.diagram.R
⊢ 𝒰.map x ≫ f₁ = 𝒰.map x ≫ f₂
state_after: no goals
tactic: exact h x
Theorem: Metric.uniformity_edist_aux
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
d : α → α → ℝ≥0
⊢ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε} = ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}
state_after: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
d : α → α → ℝ≥0
⊢ (∀ i > 0, {p | ↑(d p.1 p.2) < i} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}) ∧
    ∀ i > 0, {p | ↑(d p.1 p.2) < i} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}
tactic: simp only [le_antisymm_iff, le_iInf_iff, le_principal_iff]
state_before: α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
d : α → α → ℝ≥0
⊢ (∀ i > 0, {p | ↑(d p.1 p.2) < i} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}) ∧
    ∀ i > 0, {p | ↑(d p.1 p.2) < i} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}
state_after: case refine_1
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
d : α → α → ℝ≥0
ε : ℝ≥0∞
hε : ε > 0
⊢ {p | ↑(d p.1 p.2) < ε} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}

case refine_2
α✝ : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α✝
α : Type u_3
d : α → α → ℝ≥0
ε : ℝ
hε : ε > 0
⊢ {p | ↑(d p.1 p.2) < ε} ∈ ⨅ ε, ⨅ (_ : ε > 0), 𝓟 {p | ↑(d p.1 p.2) < ε}
tactic: refine ⟨fun ε hε => ?_, fun ε hε => ?_⟩
Theorem: CategoryTheory.Sieve.generateSingleton_eq
File: Mathlib/CategoryTheory/Sites/EffectiveEpimorphic.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : Y ⟶ X
⊢ generate (Presieve.singleton f) = generateSingleton f
state_after: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : Y ⟶ X
Z : C
g : Z ⟶ X
⊢ (generate (Presieve.singleton f)).arrows g ↔ (generateSingleton f).arrows g
tactic: ext Z g
state_before: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : Y ⟶ X
Z : C
g : Z ⟶ X
⊢ (generate (Presieve.singleton f)).arrows g ↔ (generateSingleton f).arrows g
state_after: case h.mp
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : Y ⟶ X
Z : C
g : Z ⟶ X
⊢ (generate (Presieve.singleton f)).arrows g → (generateSingleton f).arrows g

case h.mpr
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : C
f : Y ⟶ X
Z : C
g : Z ⟶ X
⊢ (generateSingleton f).arrows g → (generate (Presieve.singleton f)).arrows g
tactic: constructor
Theorem: FractionalIdeal.one_div_spanSingleton
File: Mathlib/RingTheory/FractionalIdeal/Operations.lean

Proof steps:
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
x : K
h : x = 0
⊢ 1 / spanSingleton R₁⁰ x = spanSingleton R₁⁰ x⁻¹
state_after: no goals
tactic: simp [h]
state_before: R : Type u_1
inst✝⁷ : CommRing R
S : Submonoid R
P : Type u_2
inst✝⁶ : CommRing P
inst✝⁵ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_3
inst✝⁴ : CommRing R₁
K : Type u_4
inst✝³ : Field K
inst✝² : Algebra R₁ K
inst✝¹ : IsFractionRing R₁ K
inst✝ : IsDomain R₁
x : K
h : ¬x = 0
⊢ spanSingleton R₁⁰ x * spanSingleton R₁⁰ x⁻¹ = 1
state_after: no goals
tactic: simp [h]
Theorem: le_iSup_iff
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝ : CompleteSemilatticeSup α
s✝ t : Set α
a b : α
s : ι → α
⊢ a ≤ iSup s ↔ ∀ (b : α), (∀ (i : ι), s i ≤ b) → a ≤ b
state_after: no goals
tactic: simp [iSup, le_sSup_iff, upperBounds]
Theorem: Multiset.mem_lists_iff
File: Mathlib/Data/Fintype/List.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s : Multiset α
l : List α
⊢ l ∈ s.lists ↔ s = ⟦l⟧
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
l a✝ : List α
⊢ l ∈ lists ⟦a✝⟧ ↔ ⟦a✝⟧ = ⟦l⟧
tactic: induction s using Quotient.inductionOn
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
l a✝ : List α
⊢ l ∈ lists ⟦a✝⟧ ↔ ⟦a✝⟧ = ⟦l⟧
state_after: no goals
tactic: simpa using perm_comm
Theorem: Set.piecewise_insert
File: Mathlib/Data/Set/Function.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ (insert j s).piecewise f g = update (s.piecewise f g) j (f j)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ (fun i => if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j)
tactic: simp (config := { unfoldPartialApp := true }) only [piecewise, mem_insert_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
⊢ (fun i => if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j)
state_after: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
i : α
⊢ (if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j) i
tactic: ext i
state_before: case h
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
i : α
⊢ (if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j) i
state_after: case pos
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
i : α
h : i = j
⊢ (if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j) i

case neg
α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
π : α → Type u_5
δ : α → Sort u_6
s : Set α
f g : (i : α) → δ i
inst✝² : (j : α) → Decidable (j ∈ s)
inst✝¹ : DecidableEq α
j : α
inst✝ : (i : α) → Decidable (i ∈ insert j s)
i : α
h : ¬i = j
⊢ (if i = j ∨ i ∈ s then f i else g i) = update (fun i => if i ∈ s then f i else g i) j (f j) i
tactic: by_cases h : i = j
Theorem: rightCoset_one
File: Mathlib/GroupTheory/Coset.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Monoid α
s : Set α
⊢ ∀ (x : α), x ∈ op 1 • s ↔ x ∈ s
state_after: no goals
tactic: simp [← image_smul]
Theorem: LinearMap.BilinForm.dualSubmodule_dualSubmodule_of_basis
File: Mathlib/LinearAlgebra/BilinearForm/DualLattice.lean

Proof steps:
state_before: R : Type u_4
S : Type u_2
M : Type u_3
inst✝⁷ : CommRing R
inst✝⁶ : Field S
inst✝⁵ : AddCommGroup M
inst✝⁴ : Algebra R S
inst✝³ : Module R M
inst✝² : Module S M
inst✝¹ : IsScalarTower R S M
B : BilinForm S M
ι : Type u_1
inst✝ : Finite ι
hB : B.Nondegenerate
hB' : B.IsSymm
b : Basis ι S M
⊢ B.dualSubmodule (B.dualSubmodule (Submodule.span R (Set.range ⇑b))) = Submodule.span R (Set.range ⇑b)
state_after: no goals
tactic: classical
  letI := FiniteDimensional.of_fintype_basis b
  rw [dualSubmodule_span_of_basis B hB, dualSubmodule_span_of_basis B hB,
    dualBasis_dualBasis B hB hB']
Theorem: ENNReal.limsup_const_mul
File: Mathlib/Order/Filter/ENNReal.lean

Proof steps:
state_before: α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
⊢ limsup (fun x => a * u x) f = a * limsup u f
state_after: case pos
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : a ≠ ⊤
⊢ limsup (fun x => a * u x) f = a * limsup u f

case neg
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : ¬a ≠ ⊤
⊢ limsup (fun x => a * u x) f = a * limsup u f
tactic: by_cases ha_top : a ≠ ⊤
state_before: case neg
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : ¬a ≠ ⊤
⊢ limsup (fun x => a * u x) f = a * limsup u f
state_after: case neg
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : a = ⊤
⊢ limsup (fun x => a * u x) f = a * limsup u f
tactic: push_neg at ha_top
state_before: case neg
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : a = ⊤
⊢ limsup (fun x => a * u x) f = a * limsup u f
state_after: case pos
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : a = ⊤
hu : u =ᶠ[f] 0
⊢ limsup (fun x => a * u x) f = a * limsup u f

case neg
α : Type u_1
f : Filter α
inst✝ : CountableInterFilter f
u : α → ℝ≥0∞
a : ℝ≥0∞
ha_top : a = ⊤
hu : ¬u =ᶠ[f] 0
⊢ limsup (fun x => a * u x) f = a * limsup u f
tactic: by_cases hu : u =ᶠ[f] 0
Theorem: MeasurableEquiv.coe_sumPiEquivProdPi
File: Mathlib/MeasureTheory/MeasurableSpace/Embedding.lean

Proof steps:
state_before: α✝ : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
δ' : Type u_5
ι : Sort uι
s t u : Set α✝
inst✝⁶ : MeasurableSpace α✝
inst✝⁵ : MeasurableSpace β
inst✝⁴ : MeasurableSpace γ
inst✝³ : MeasurableSpace δ
π : δ' → Type u_6
π' : δ' → Type u_7
inst✝² : (x : δ') → MeasurableSpace (π x)
inst✝¹ : (x : δ') → MeasurableSpace (π' x)
α : δ ⊕ δ' → Type u_8
inst✝ : (i : δ ⊕ δ') → MeasurableSpace (α i)
⊢ ⇑(sumPiEquivProdPi α) = ⇑(Equiv.sumPiEquivProdPi α)
state_after: no goals
tactic: rfl
Theorem: Coheyting.boundary_top
File: Mathlib/Order/Heyting/Boundary.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a b : α
⊢ ∂ ⊤ = ⊥
state_after: no goals
tactic: rw [boundary, hnot_top, inf_bot_eq]
Theorem: Matroid.Indep.insert_indep_iff
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
⊢ M.Indep (insert e I) ↔ e ∈ M.E \ M.closure I ∨ e ∈ I
state_after: case inl
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
h : e ∈ I
⊢ M.Indep (insert e I) ↔ e ∈ M.E \ M.closure I ∨ e ∈ I

case inr
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
h : e ∉ I
⊢ M.Indep (insert e I) ↔ e ∈ M.E \ M.closure I ∨ e ∈ I
tactic: obtain (h | h) := em (e ∈ I)
state_before: case inr
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hI : M.Indep I
h : e ∉ I
⊢ M.Indep (insert e I) ↔ e ∈ M.E \ M.closure I ∨ e ∈ I
state_after: no goals
tactic: rw [hI.insert_indep_iff_of_not_mem h, or_iff_left h]
Theorem: MeasurableSpace.separating_of_generateFrom
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
⊢ ∀ (x y : α), (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
state_after: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
⊢ ∀ (x y : α), (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
tactic: letI := generateFrom S
state_before: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
⊢ ∀ (x y : α), (∀ s ∈ S, x ∈ s ↔ y ∈ s) → x = y
state_after: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
x y : α
hxy : ∀ s ∈ S, x ∈ s ↔ y ∈ s
⊢ x = y
tactic: intros x y hxy
state_before: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
x y : α
hxy : ∀ s ∈ S, x ∈ s ↔ y ∈ s
⊢ x = y
state_after: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
x y : α
hxy : ∀ (s : Set α), MeasurableSet s → (x ∈ s ↔ y ∈ s)
⊢ x = y
tactic: rw [← forall_generateFrom_mem_iff_mem_iff] at hxy
state_before: α : Type u_1
β : Type u_2
S : Set (Set α)
h : SeparatesPoints α
this : MeasurableSpace α := generateFrom S
x y : α
hxy : ∀ (s : Set α), MeasurableSet s → (x ∈ s ↔ y ∈ s)
⊢ x = y
state_after: no goals
tactic: exact separatesPoints_def $ fun _ hs ↦ (hxy _ hs).mp