ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: FreeAddSemigroup.lift_symm_apply
File: Mathlib/Algebra/Free.lean

Proof steps:
state_before: α : Type u
β : Type v
inst✝ : Semigroup β
f✝ f : α → β
x y : FreeSemigroup α
⊢ (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) (x * y) =
    (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) x *
      (fun x => List.foldl (fun a b => a * f b) (f x.head) x.tail) y
state_after: no goals
tactic: simp [head_mul, tail_mul, ← List.foldl_map, List.foldl_append, List.foldl_cons,
          List.foldl_assoc]
Theorem: CategoryTheory.Limits.HasLimit.isoOfEquivalence_inv_π
File: Mathlib/CategoryTheory/Limits/HasLimits.lean

Proof steps:
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasLimit F
G : K ⥤ C
inst✝ : HasLimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ (isoOfEquivalence e w).inv ≫ limit.π F j = limit.π G (e.functor.obj j) ≫ w.hom.app j
state_after: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasLimit F
G : K ⥤ C
inst✝ : HasLimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ ((limit.isLimit F).conePointsIsoOfEquivalence (limit.isLimit G) e w).inv ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j
tactic: simp only [HasLimit.isoOfEquivalence, IsLimit.conePointsIsoOfEquivalence_hom]
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasLimit F
G : K ⥤ C
inst✝ : HasLimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ ((limit.isLimit F).conePointsIsoOfEquivalence (limit.isLimit G) e w).inv ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j
state_after: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasLimit F
G : K ⥤ C
inst✝ : HasLimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ limit.lift F ((Cones.postcompose w.hom).obj (Cone.whisker e.functor (limit.cone G))) ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j
tactic: dsimp
state_before: J : Type u₁
inst✝⁴ : Category.{v₁, u₁} J
K : Type u₂
inst✝³ : Category.{v₂, u₂} K
C : Type u
inst✝² : Category.{v, u} C
F✝ F : J ⥤ C
inst✝¹ : HasLimit F
G : K ⥤ C
inst✝ : HasLimit G
e : J ≌ K
w : e.functor ⋙ G ≅ F
j : J
⊢ limit.lift F ((Cones.postcompose w.hom).obj (Cone.whisker e.functor (limit.cone G))) ≫ limit.π F j =
    limit.π G (e.functor.obj j) ≫ w.hom.app j
state_after: no goals
tactic: simp
Theorem: Relation.comp_assoc
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
⊢ (r ∘r p) ∘r q = r ∘r p ∘r q
state_after: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d = (r ∘r p ∘r q) a d
tactic: funext a d
state_before: case h.h
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d = (r ∘r p ∘r q) a d
state_after: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d ↔ (r ∘r p ∘r q) a d
tactic: apply propext
state_before: case h.h.a
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d ↔ (r ∘r p ∘r q) a d
state_after: case h.h.a.mp
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ ((r ∘r p) ∘r q) a d → (r ∘r p ∘r q) a d

case h.h.a.mpr
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → β → Prop
p : β → γ → Prop
q : γ → δ → Prop
a : α
d : δ
⊢ (r ∘r p ∘r q) a d → ((r ∘r p) ∘r q) a d
tactic: constructor
Theorem: Submonoid.coe_iSup_of_directed
File: Mathlib/Algebra/Group/Submonoid/Membership.lean

Proof steps:
state_before: M : Type u_1
A : Type u_2
B : Type u_3
inst✝¹ : MulOneClass M
ι : Sort u_4
inst✝ : Nonempty ι
S : ι → Submonoid M
hS : Directed (fun x x_1 => x ≤ x_1) S
x : M
⊢ x ∈ ↑(⨆ i, S i) ↔ x ∈ ⋃ i, ↑(S i)
state_after: no goals
tactic: simp [mem_iSup_of_directed hS]
Theorem: Matroid.inter_ground_subset_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
M : Matroid α
X : Set α
⊢ X ∩ M.E ⊆ M.closure X
state_after: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
M : Matroid α
X : Set α
⊢ ∀ t' ∈ {F | M.Flat F ∧ X ∩ M.E ⊆ F}, X ∩ M.E ⊆ t'
tactic: simp_rw [closure_def, subset_sInter_iff]
state_before: ι : Type u_1
α : Type u_2
M✝ : Matroid α
F X✝ Y : Set α
e : α
M : Matroid α
X : Set α
⊢ ∀ t' ∈ {F | M.Flat F ∧ X ∩ M.E ⊆ F}, X ∩ M.E ⊆ t'
state_after: no goals
tactic: aesop
Theorem: unique_uniformity_of_compact
File: Mathlib/Topology/UniformSpace/Compact.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ u = u'
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ 𝓤 γ = 𝓤 γ
tactic: refine UniformSpace.ext ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
⊢ 𝓤 γ = 𝓤 γ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
tactic: have : @CompactSpace γ u.toTopologicalSpace := by rwa [h]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this✝ : CompactSpace γ
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
tactic: have : @CompactSpace γ u'.toTopologicalSpace := by rwa [h']
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
t : TopologicalSpace γ
inst✝ : CompactSpace γ
u u' : UniformSpace γ
h : toTopologicalSpace = t
h' : toTopologicalSpace = t
this✝ : CompactSpace γ
this : CompactSpace γ
⊢ 𝓤 γ = 𝓤 γ
state_after: no goals
tactic: rw [@compactSpace_uniformity _ u, compactSpace_uniformity, h, h']
Theorem: List.countP_mono_left
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
p q : α → Bool
l : List α
h : ∀ (x : α), x ∈ l → p x = true → q x = true
⊢ countP p l ≤ countP q l
state_after: no goals
tactic: induction l with
  | nil => apply Nat.le_refl
  | cons a l ihl =>
    rw [forall_mem_cons] at h
    have ⟨ha, hl⟩ := h
    simp [countP_cons]
    cases h : p a
    . simp
      apply Nat.le_trans ?_ (Nat.le_add_right _ _)
      apply ihl hl
    . simp [ha h]
      apply ihl hl
Theorem: fderiv_inv
File: Mathlib/Analysis/Calculus/Deriv/Inv.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type v
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type w
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
f f₀ f₁ g : 𝕜 → F
f' f₀' f₁' g' : F
x : 𝕜
s t : Set 𝕜
L : Filter 𝕜
⊢ fderiv 𝕜 (fun x => x⁻¹) x = smulRight 1 (-(x ^ 2)⁻¹)
state_after: no goals
tactic: rw [← deriv_fderiv, deriv_inv]
Theorem: Nat.factorization_pow
File: Mathlib/Data/Nat/Factorization/Defs.lean

Proof steps:
state_before: a b m n✝ p n k : ℕ
⊢ (n ^ k).factorization = k • n.factorization
state_after: case zero
a b m n✝ p n : ℕ
⊢ (n ^ 0).factorization = 0 • n.factorization

case succ
a b m n✝ p n k : ℕ
ih : (n ^ k).factorization = k • n.factorization
⊢ (n ^ (k + 1)).factorization = (k + 1) • n.factorization
tactic: induction' k with k ih
state_before: case succ
a b m n✝ p n k : ℕ
ih : (n ^ k).factorization = k • n.factorization
⊢ (n ^ (k + 1)).factorization = (k + 1) • n.factorization
state_after: case succ.inl
a b m n p k : ℕ
ih : (0 ^ k).factorization = k • factorization 0
⊢ (0 ^ (k + 1)).factorization = (k + 1) • factorization 0

case succ.inr
a b m n✝ p n k : ℕ
ih : (n ^ k).factorization = k • n.factorization
hn : n ≠ 0
⊢ (n ^ (k + 1)).factorization = (k + 1) • n.factorization
tactic: rcases eq_or_ne n 0 with (rfl | hn)
state_before: case succ.inr
a b m n✝ p n k : ℕ
ih : (n ^ k).factorization = k • n.factorization
hn : n ≠ 0
⊢ (n ^ (k + 1)).factorization = (k + 1) • n.factorization
state_after: no goals
tactic: rw [Nat.pow_succ, mul_comm, factorization_mul hn (pow_ne_zero _ hn), ih,
    add_smul, one_smul, add_comm]
Theorem: List.drop_sublist_drop_left
File: Mathlib/Data/List/Infix.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m✝ n✝ : ℕ
l : List α
m n : ℕ
h : m ≤ n
⊢ drop n l <+ drop m l
state_after: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m✝ n✝ : ℕ
l : List α
m n : ℕ
h : m ≤ n
⊢ drop (n - m) (drop m l) <+ drop m l
tactic: rw [← Nat.sub_add_cancel h, ← drop_drop]
state_before: α : Type u_1
β : Type u_2
l✝ l₁ l₂ l₃ : List α
a b : α
m✝ n✝ : ℕ
l : List α
m n : ℕ
h : m ≤ n
⊢ drop (n - m) (drop m l) <+ drop m l
state_after: no goals
tactic: apply drop_sublist
Theorem: MeasureTheory.Measure.IsEverywherePos.smul_measure
File: Mathlib/MeasureTheory/Measure/EverywherePos.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
inst✝ : MeasurableSpace α
μ ν : Measure α
s k : Set α
hs : μ.IsEverywherePos s
c : ℝ≥0∞
hc : c ≠ 0
x : α
hx : x ∈ s
n : Set α
hn : n ∈ 𝓝[s] x
⊢ 0 < (c • μ) n
state_after: no goals
tactic: simpa [hc.bot_lt, hs x hx n hn] using hc.bot_lt
Theorem: Homotopy.nullHomotopicMap_f_eq_zero
File: Mathlib/Algebra/Homology/Homotopy.lean

Proof steps:
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₀ : ι
hk₀ : ∀ (l : ι), ¬c.Rel k₀ l
hk₀' : ∀ (l : ι), ¬c.Rel l k₀
hom : (i j : ι) → C.X i ⟶ D.X j
⊢ (nullHomotopicMap hom).f k₀ = 0
state_after: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₀ : ι
hk₀ : ∀ (l : ι), ¬c.Rel k₀ l
hk₀' : ∀ (l : ι), ¬c.Rel l k₀
hom : (i j : ι) → C.X i ⟶ D.X j
⊢ C.d k₀ (c.next k₀) ≫ hom (c.next k₀) k₀ + hom k₀ (c.prev k₀) ≫ D.d (c.prev k₀) k₀ = 0
tactic: dsimp [nullHomotopicMap, dNext, prevD]
state_before: ι : Type u_1
V : Type u
inst✝¹ : Category.{v, u} V
inst✝ : Preadditive V
c : ComplexShape ι
C D E : HomologicalComplex V c
f g : C ⟶ D
h k : D ⟶ E
i k₀ : ι
hk₀ : ∀ (l : ι), ¬c.Rel k₀ l
hk₀' : ∀ (l : ι), ¬c.Rel l k₀
hom : (i j : ι) → C.X i ⟶ D.X j
⊢ C.d k₀ (c.next k₀) ≫ hom (c.next k₀) k₀ + hom k₀ (c.prev k₀) ≫ D.d (c.prev k₀) k₀ = 0
state_after: no goals
tactic: rw [C.shape, D.shape, zero_comp, comp_zero, add_zero] <;> apply_assumption
Theorem: Subgroup.IsComplement.coe_equiv_fst_eq_one_iff_mem
File: Mathlib/GroupTheory/Complement.lean

Proof steps:
state_before: G : Type u_1
inst✝ : Group G
H K : Subgroup G
S T : Set G
hST : IsComplement S T
hHT : IsComplement (↑H) T
hSK : IsComplement S ↑K
g : G
h1 : 1 ∈ S
⊢ ↑(hST.equiv g).1 = 1 ↔ g ∈ T
state_after: no goals
tactic: rw [equiv_fst_eq_mul_inv, mul_inv_eq_one, eq_comm, equiv_snd_eq_self_iff_mem _ h1]
Theorem: Polynomial.hasseDeriv_C
File: Mathlib/Algebra/Polynomial/HasseDeriv.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
k : ℕ
f : R[X]
r : R
hk : 0 < k
⊢ (hasseDeriv k) (C r) = 0
state_after: no goals
tactic: rw [← monomial_zero_left, hasseDeriv_monomial, Nat.choose_eq_zero_of_lt hk, Nat.cast_zero,
    zero_mul, monomial_zero_right]
Theorem: Filter.eventually_swap_iff
File: Mathlib/Order/Filter/Prod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
⊢ (∀ᶠ (x : α × β) in f ×ˢ g, p x) ↔ ∀ᶠ (y : β × α) in g ×ˢ f, p y.swap
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
⊢ (∀ᶠ (x : α × β) in map (fun p => (p.2, p.1)) (g ×ˢ f), p x) ↔ ∀ᶠ (y : β × α) in g ×ˢ f, p y.swap
tactic: rw [prod_comm]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Sort u_5
s : Set α
t : Set β
f : Filter α
g : Filter β
p : α × β → Prop
⊢ (∀ᶠ (x : α × β) in map (fun p => (p.2, p.1)) (g ×ˢ f), p x) ↔ ∀ᶠ (y : β × α) in g ×ˢ f, p y.swap
state_after: no goals
tactic: rfl
Theorem: PartialHomeomorph.isLittleO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ f =o[𝓝 b] g ↔ (f ∘ ↑e) =o[𝓝 (↑e.symm b)] (g ∘ ↑e)
state_after: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 b) f g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 (↑e.symm b)) (f ∘ ↑e) (g ∘ ↑e)
tactic: simp only [IsLittleO_def]
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
⊢ (∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 b) f g) ↔ ∀ ⦃c : ℝ⦄, 0 < c → IsBigOWith c (𝓝 (↑e.symm b)) (f ∘ ↑e) (g ∘ ↑e)
state_after: no goals
tactic: exact forall₂_congr fun c _hc => e.isBigOWith_congr hb
Theorem: Matrix.toLinearMap₂'_comp
File: Mathlib/LinearAlgebra/Matrix/SesquilinearForm.lean

Proof steps:
state_before: R✝ : Type u_1
R₁ : Type u_2
S₁ : Type u_3
R₂ : Type u_4
S₂ : Type u_5
M✝ : Type u_6
M₁ : Type u_7
M₂ : Type u_8
M₁' : Type u_9
M₂' : Type u_10
N₂ : Type u_11
n : Type u_12
m : Type u_13
n' : Type u_14
m' : Type u_15
ι : Type u_16
R : Type u_17
inst✝⁸ : CommSemiring R
inst✝⁷ : Fintype n
inst✝⁶ : Fintype m
inst✝⁵ : DecidableEq n
inst✝⁴ : DecidableEq m
inst✝³ : Fintype n'
inst✝² : Fintype m'
inst✝¹ : DecidableEq n'
inst✝ : DecidableEq m'
M : Matrix n m R
P : Matrix n n' R
Q : Matrix m m' R
⊢ (toMatrix₂' R) (((toLinearMap₂' R) M).compl₁₂ (toLin' P) (toLin' Q)) = (toMatrix₂' R) ((toLinearMap₂' R) (Pᵀ * M * Q))
state_after: no goals
tactic: simp
Theorem: BoxIntegral.Box.disjoint_splitCenterBox
File: Mathlib/Analysis/BoxIntegral/Box/SubboxInduction.lean

Proof steps:
state_before: ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
⊢ Disjoint ↑(I.splitCenterBox s) ↑(I.splitCenterBox t)
state_after: ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
⊢ ↑(I.splitCenterBox s) ⊓ ↑(I.splitCenterBox t) ≤ ⊥
tactic: rw [disjoint_iff_inf_le]
state_before: ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
⊢ ↑(I.splitCenterBox s) ⊓ ↑(I.splitCenterBox t) ≤ ⊥
state_after: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
⊢ y ∈ ⊥
tactic: rintro y ⟨hs, ht⟩
state_before: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
⊢ y ∈ ⊥
state_after: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
⊢ s = t
tactic: apply h
state_before: case intro
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
⊢ s = t
state_after: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
i : ι
⊢ i ∈ s ↔ i ∈ t
tactic: ext i
state_before: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ ↑(I.splitCenterBox s)
ht : y ∈ ↑(I.splitCenterBox t)
i : ι
⊢ i ∈ s ↔ i ∈ t
state_after: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ I ∧ ∀ (i : ι), (I.lower i + I.upper i) / 2 < y i ↔ i ∈ s
ht : y ∈ I ∧ ∀ (i : ι), (I.lower i + I.upper i) / 2 < y i ↔ i ∈ t
i : ι
⊢ i ∈ s ↔ i ∈ t
tactic: rw [mem_coe, mem_splitCenterBox] at hs ht
state_before: case intro.h
ι : Type u_1
I✝ J I : Box ι
s t : Set ι
h : s ≠ t
y : ι → ℝ
hs : y ∈ I ∧ ∀ (i : ι), (I.lower i + I.upper i) / 2 < y i ↔ i ∈ s
ht : y ∈ I ∧ ∀ (i : ι), (I.lower i + I.upper i) / 2 < y i ↔ i ∈ t
i : ι
⊢ i ∈ s ↔ i ∈ t
state_after: no goals
tactic: rw [← hs.2, ← ht.2]
Theorem: SimpleGraph.ConnectedComponent.even_card_of_isPerfectMatching
File: Mathlib/Combinatorics/SimpleGraph/Matching.lean

Proof steps:
state_before: V : Type u_1
G G' : SimpleGraph V
M M' : G.Subgraph
v w : V
inst✝² : Fintype V
inst✝¹ : DecidableRel G.Adj
inst✝ : DecidableEq V
c : G.ConnectedComponent
hM : M.IsPerfectMatching
⊢ Even (Fintype.card ↑c.supp)
state_after: no goals
tactic: classical simpa using (hM.induce_connectedComponent_isMatching c).even_card
Theorem: CategoryTheory.ShortComplex.RightHomologyMapData.op_φH
File: Mathlib/Algebra/Homology/ShortComplex/RightHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{?u.154535, u_1} C
inst✝ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
ψ : RightHomologyMapData φ h₁ h₂
⊢ (ψ.φQ.op ≫ h₁.op.i).unop = (h₂.op.i ≫ (opMap φ).τ₂).unop
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.154535, u_1} C
inst✝ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
ψ : RightHomologyMapData φ h₁ h₂
⊢ (h₂.op.f' ≫ ψ.φQ.op).unop = ((opMap φ).τ₁ ≫ h₁.op.f').unop
state_after: no goals
tactic: simp
state_before: C : Type u_1
inst✝¹ : Category.{?u.154535, u_1} C
inst✝ : HasZeroMorphisms C
S S₁✝ S₂✝ S₃ S₁ S₂ : ShortComplex C
φ : S₁ ⟶ S₂
h₁ : S₁.RightHomologyData
h₂ : S₂.RightHomologyData
ψ : RightHomologyMapData φ h₁ h₂
⊢ (h₂.op.π ≫ ψ.φH.op).unop = (ψ.φQ.op ≫ h₁.op.π).unop
state_after: no goals
tactic: simp
Theorem: Units.mul_eq_one_iff_eq_inv
File: Mathlib/Algebra/Group/Units.lean

Proof steps:
state_before: α : Type u
inst✝ : Monoid α
a✝ b c u : αˣ
a : α
⊢ a * ↑u = 1 ↔ a = ↑u⁻¹
state_after: no goals
tactic: rw [← mul_inv_eq_one, inv_inv]
Theorem: Algebra.leftMulMatrix_injective
File: Mathlib/LinearAlgebra/Matrix/ToLin.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝⁴ : CommRing R
inst✝³ : Ring S
inst✝² : Algebra R S
m : Type u_3
inst✝¹ : Fintype m
inst✝ : DecidableEq m
b : Basis m R S
x x' : S
h : (leftMulMatrix b) x = (leftMulMatrix b) x'
⊢ ((lmul R S) x) 1 = ((lmul R S) x') 1
state_after: no goals
tactic: rw [(LinearMap.toMatrix b b).injective h]
Theorem: MeasureTheory.IsStoppingTime.measurableSet_gt'
File: Mathlib/Probability/Process/Stopping.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
⊢ MeasurableSet {ω | i < τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i < τ ω} = {ω | τ ω ≤ i}ᶜ
⊢ MeasurableSet {ω | i < τ ω}
tactic: have : {ω : Ω | i < τ ω} = {ω : Ω | τ ω ≤ i}ᶜ := by ext1 ω; simp
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i < τ ω} = {ω | τ ω ≤ i}ᶜ
⊢ MeasurableSet {ω | i < τ ω}
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i < τ ω} = {ω | τ ω ≤ i}ᶜ
⊢ MeasurableSet {ω | τ ω ≤ i}ᶜ
tactic: rw [this]
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m : MeasurableSpace Ω
inst✝ : LinearOrder ι
f : Filtration ι m
τ π : Ω → ι
hτ : IsStoppingTime f τ
i : ι
this : {ω | i < τ ω} = {ω | τ ω ≤ i}ᶜ
⊢ MeasurableSet {ω | τ ω ≤ i}ᶜ
state_after: no goals
tactic: exact (hτ.measurableSet_le' i).compl
Theorem: Matrix.IsDiag.neg
File: Mathlib/LinearAlgebra/Matrix/IsDiag.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A : Matrix n n α
ha : A.IsDiag
⊢ (-A).IsDiag
state_after: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A : Matrix n n α
ha : A.IsDiag
i j : n
h : i ≠ j
⊢ (-A) i j = 0
tactic: intro i j h
state_before: α : Type u_1
β : Type u_2
R : Type u_3
n : Type u_4
m : Type u_5
inst✝ : AddGroup α
A : Matrix n n α
ha : A.IsDiag
i j : n
h : i ≠ j
⊢ (-A) i j = 0
state_after: no goals
tactic: simp [ha h]
Theorem: ContinuousLinearMap.coe_sum'
File: Mathlib/Topology/Algebra/Module/Basic.lean

Proof steps:
state_before: R₁ : Type u_1
R₂ : Type u_2
R₃ : Type u_3
inst✝¹⁷ : Semiring R₁
inst✝¹⁶ : Semiring R₂
inst✝¹⁵ : Semiring R₃
σ₁₂ : R₁ →+* R₂
σ₂₃ : R₂ →+* R₃
σ₁₃ : R₁ →+* R₃
M₁ : Type u_4
inst✝¹⁴ : TopologicalSpace M₁
inst✝¹³ : AddCommMonoid M₁
M'₁ : Type u_5
inst✝¹² : TopologicalSpace M'₁
inst✝¹¹ : AddCommMonoid M'₁
M₂ : Type u_6
inst✝¹⁰ : TopologicalSpace M₂
inst✝⁹ : AddCommMonoid M₂
M₃ : Type u_7
inst✝⁸ : TopologicalSpace M₃
inst✝⁷ : AddCommMonoid M₃
M₄ : Type u_8
inst✝⁶ : TopologicalSpace M₄
inst✝⁵ : AddCommMonoid M₄
inst✝⁴ : Module R₁ M₁
inst✝³ : Module R₁ M'₁
inst✝² : Module R₂ M₂
inst✝¹ : Module R₃ M₃
inst✝ : ContinuousAdd M₂
ι : Type u_9
t : Finset ι
f : ι → M₁ →SL[σ₁₂] M₂
⊢ ⇑(∑ d ∈ t, f d) = ∑ d ∈ t, ⇑(f d)
state_after: no goals
tactic: simp only [← coe_coe, coe_sum, LinearMap.coeFn_sum]