ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: rotation_ne_conjLIE
File: Mathlib/Analysis/Complex/Isometry.lean

Proof steps:
state_before: a : ↥circle
⊢ rotation a ≠ conjLIE
state_after: a : ↥circle
h : rotation a = conjLIE
⊢ False
tactic: intro h
state_before: a : ↥circle
h : rotation a = conjLIE
⊢ False
state_after: a : ↥circle
h : rotation a = conjLIE
h1 : (rotation a) 1 = (starRingEnd ℂ) 1
⊢ False
tactic: have h1 : rotation a 1 = conj 1 := LinearIsometryEquiv.congr_fun h 1
state_before: a : ↥circle
h : rotation a = conjLIE
h1 : (rotation a) 1 = (starRingEnd ℂ) 1
⊢ False
state_after: a : ↥circle
h : rotation a = conjLIE
h1 : (rotation a) 1 = (starRingEnd ℂ) 1
hI : (rotation a) I = (starRingEnd ℂ) I
⊢ False
tactic: have hI : rotation a I = conj I := LinearIsometryEquiv.congr_fun h I
state_before: a : ↥circle
h : rotation a = conjLIE
h1 : (rotation a) 1 = (starRingEnd ℂ) 1
hI : (rotation a) I = (starRingEnd ℂ) I
⊢ False
state_after: a : ↥circle
h : rotation a = conjLIE
h1 : ↑a = 1
hI : (rotation a) I = (starRingEnd ℂ) I
⊢ False
tactic: rw [rotation_apply, RingHom.map_one, mul_one] at h1
state_before: a : ↥circle
h : rotation a = conjLIE
h1 : ↑a = 1
hI : (rotation a) I = (starRingEnd ℂ) I
⊢ False
state_after: a : ↥circle
h : rotation a = conjLIE
h1 : ↑a = 1
hI : 1 = 0
⊢ False
tactic: rw [rotation_apply, conj_I, ← neg_one_mul, mul_left_inj' I_ne_zero, h1, eq_neg_self_iff] at hI
state_before: a : ↥circle
h : rotation a = conjLIE
h1 : ↑a = 1
hI : 1 = 0
⊢ False
state_after: no goals
tactic: exact one_ne_zero hI
Theorem: List.getElem?_getD_replicate_default_eq
File: Mathlib/Data/List/GetD.lean

Proof steps:
state_before: α : Type u
β : Type v
l : List α
x : α
xs : List α
n✝ : ℕ
d : α
r n : ℕ
⊢ (replicate r d)[n]?.getD d = d
state_after: no goals
tactic: induction r generalizing n with
  | zero => simp
  | succ n ih => simp at ih; cases n <;> simp [ih, replicate_succ]
Theorem: variationOnFromTo.eq_of_ge
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
a b : α
h : b ≤ a
⊢ variationOnFromTo f s a b = -(eVariationOn f (s ∩ Icc b a)).toReal
state_after: no goals
tactic: rw [variationOnFromTo.eq_neg_swap, neg_inj, variationOnFromTo.eq_of_le f s h]
Theorem: Real.surjOn_log'
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x✝¹ y x : ℝ
x✝ : x ∈ univ
⊢ log (-rexp x) = x
state_after: no goals
tactic: rw [log_neg_eq_log, log_exp]
Theorem: CoxeterSystem.isLeftDescent_iff_not_isLeftDescent_mul
File: Mathlib/GroupTheory/Coxeter/Length.lean

Proof steps:
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.IsLeftDescent w i ↔ ¬cs.IsLeftDescent (cs.simple i * w) i
state_after: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) + 1 = cs.length w ↔ cs.length w = cs.length (cs.simple i * w) + 1
tactic: rw [isLeftDescent_iff, not_isLeftDescent_iff, simple_mul_simple_cancel_left]
state_before: B : Type u_1
W : Type u_2
inst✝ : Group W
M : CoxeterMatrix B
cs : CoxeterSystem M W
w : W
i : B
⊢ cs.length (cs.simple i * w) + 1 = cs.length w ↔ cs.length w = cs.length (cs.simple i * w) + 1
state_after: no goals
tactic: tauto
Theorem: Nat.Ioc_filter_dvd_card_eq_div
File: Mathlib/Data/Nat/Factorization/Basic.lean

Proof steps:
state_before: a b m n✝ p✝ n p : ℕ
⊢ (Finset.filter (fun x => p ∣ x) (Ioc 0 n)).card = n / p
state_after: case zero
a b m n p✝ p : ℕ
⊢ (Finset.filter (fun x => p ∣ x) (Ioc 0 0)).card = 0 / p

case succ
a b m n✝ p✝ p n : ℕ
IH : (Finset.filter (fun x => p ∣ x) (Ioc 0 n)).card = n / p
⊢ (Finset.filter (fun x => p ∣ x) (Ioc 0 (n + 1))).card = (n + 1) / p
tactic: induction' n with n IH
state_before: case succ
a b m n✝ p✝ p n : ℕ
IH : (Finset.filter (fun x => p ∣ x) (Ioc 0 n)).card = n / p
h1 : Ioc 0 n.succ = insert n.succ (Ioc 0 n)
⊢ (Finset.filter (fun x => p ∣ x) (Ioc 0 (n + 1))).card = (n + 1) / p
state_after: no goals
tactic: simp [Nat.succ_div, add_ite, add_zero, h1, filter_insert, apply_ite card, card_insert_eq_ite, IH,
    Finset.mem_filter, mem_Ioc, not_le.2 (lt_add_one n)]
Theorem: SimpleGraph.Colorable.cliqueFree
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n m : ℕ
hc : G.Colorable n
hm : n < m
⊢ G.CliqueFree m
state_after: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n m : ℕ
hc : G.Colorable n
hm : n < m
h : ¬G.CliqueFree m
⊢ False
tactic: by_contra h
state_before: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n m : ℕ
hc : G.Colorable n
hm : n < m
h : ¬G.CliqueFree m
⊢ False
state_after: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n m : ℕ
hc : G.Colorable n
hm : n < m
h : ∃ x, G.IsClique ↑x ∧ x.card = m
⊢ False
tactic: simp only [CliqueFree, isNClique_iff, not_forall, Classical.not_not] at h
state_before: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n m : ℕ
hc : G.Colorable n
hm : n < m
h : ∃ x, G.IsClique ↑x ∧ x.card = m
⊢ False
state_after: case intro.intro
V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n : ℕ
hc : G.Colorable n
s : Finset V
h : G.IsClique ↑s
hm : n < s.card
⊢ False
tactic: obtain ⟨s, h, rfl⟩ := h
state_before: case intro.intro
V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n : ℕ
hc : G.Colorable n
s : Finset V
h : G.IsClique ↑s
hm : n < s.card
⊢ False
state_after: no goals
tactic: exact Nat.lt_le_asymm hm (h.card_le_of_colorable hc)
Theorem: Lists'.mem_cons
File: Mathlib/SetTheory/Lists.lean

Proof steps:
state_before: α : Type u_1
a y : Lists α
l : Lists' α true
⊢ a ∈ cons y l ↔ a ~ y ∨ a ∈ l
state_after: no goals
tactic: simp [mem_def, or_and_right, exists_or]
Theorem: Ordinal.lsub_typein
File: Mathlib/SetTheory/Ordinal/Arithmetic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
⊢ o ≤ lsub (typein fun x x_1 => x < x_1)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
h : lsub (typein fun x x_1 => x < x_1) < o
⊢ False
tactic: by_contra! h
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
h : lsub (typein fun x x_1 => x < x_1) < o
⊢ False
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
o : Ordinal.{u}
h : lsub (typein fun x x_1 => x < x_1) < type fun x x_1 => x < x_1
⊢ False
tactic: conv_rhs at h => rw [← type_lt o]
Theorem: Matrix.zpow_neg_mul_zpow_self
File: Mathlib/LinearAlgebra/Matrix/ZPow.lean

Proof steps:
state_before: n' : Type u_1
inst✝² : DecidableEq n'
inst✝¹ : Fintype n'
R : Type u_2
inst✝ : CommRing R
n : ℤ
A : M
h : IsUnit A.det
⊢ A ^ (-n) * A ^ n = 1
state_after: no goals
tactic: rw [zpow_neg h, nonsing_inv_mul _ (h.det_zpow _)]
Theorem: hasFDerivAtFilter_iff_hasDerivAtFilter
File: Mathlib/Analysis/Calculus/Deriv/Basic.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 L₁ L₂ : Filter 𝕜
f' : 𝕜 →L[𝕜] F
⊢ HasFDerivAtFilter f f' x L ↔ HasDerivAtFilter f (f' 1) x L
state_after: no goals
tactic: simp [HasDerivAtFilter]
Theorem: continuousOn_iff_lower_upperSemicontinuousOn
File: Mathlib/Topology/Semicontinuous.lean

Proof steps:
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ ContinuousOn f s ↔ LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s
state_after: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ (∀ x ∈ s, LowerSemicontinuousWithinAt f s x ∧ UpperSemicontinuousWithinAt f s x) ↔
    LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s
tactic: simp only [ContinuousOn, continuousWithinAt_iff_lower_upperSemicontinuousWithinAt]
state_before: α : Type u_1
inst✝⁴ : TopologicalSpace α
β : Type u_2
inst✝³ : Preorder β
f✝ g : α → β
x : α
s t : Set α
y z : β
γ : Type u_3
inst✝² : LinearOrder γ
inst✝¹ : TopologicalSpace γ
inst✝ : OrderTopology γ
f : α → γ
⊢ (∀ x ∈ s, LowerSemicontinuousWithinAt f s x ∧ UpperSemicontinuousWithinAt f s x) ↔
    LowerSemicontinuousOn f s ∧ UpperSemicontinuousOn f s
state_after: no goals
tactic: exact
    ⟨fun H => ⟨fun x hx => (H x hx).1, fun x hx => (H x hx).2⟩, fun H x hx => ⟨H.1 x hx, H.2 x hx⟩⟩
Theorem: Complex.cosh_sub_sinh
File: Mathlib/Data/Complex/Exponential.lean

Proof steps:
state_before: x y : ℂ
⊢ cosh x - sinh x = cexp (-x)
state_after: no goals
tactic: rw [← mul_right_inj' (two_ne_zero' ℂ), mul_sub, two_cosh, two_sinh, add_sub_sub_cancel, two_mul]
Theorem: ProbabilityTheory.IsCondKernelCDF.integral
File: Mathlib/Probability/Kernel/Disintegration/CdfToKernel.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
κ : Kernel α (β × ℝ)
ν : Kernel α β
f✝ f : α × β → StieltjesFunction
hf : IsCondKernelCDF f κ ν
a : α
x : ℝ
⊢ ∫ (b : β), ↑(f (a, b)) x ∂ν a = ((κ a) (univ ×ˢ Iic x)).toReal
state_after: no goals
tactic: rw [← hf.setIntegral _ MeasurableSet.univ, Measure.restrict_univ]
Theorem: Topology.IsUpperSet.isClosed_iff_isLower
File: Mathlib/Topology/Order/UpperLowerSetTopology.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝² : Preorder α
inst✝¹ : TopologicalSpace α
inst✝ : Topology.IsUpperSet α
s : Set α
⊢ IsClosed s ↔ IsLowerSet s
state_after: no goals
tactic: rw [← isOpen_compl_iff, isOpen_iff_isUpperSet,
    isLowerSet_compl.symm, compl_compl]
Theorem: Coheyting.boundary_hnot_hnot
File: Mathlib/Order/Heyting/Boundary.lean

Proof steps:
state_before: α : Type u_1
inst✝ : CoheytingAlgebra α
a✝ b a : α
⊢ ∂ (￢￢a) = ∂ (￢a)
state_after: no goals
tactic: simp_rw [boundary, hnot_hnot_hnot, inf_comm]
Theorem: AddOreLocalization.vadd_oreSub_zero
File: Mathlib/RingTheory/OreLocalization/Basic.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
M : Type u_3
X : Type u_4
inst✝¹² : Monoid M
S : Submonoid M
inst✝¹¹ : OreSet S
inst✝¹⁰ : MulAction M X
inst✝⁹ : SMul R X
inst✝⁸ : SMul R M
inst✝⁷ : IsScalarTower R M M
inst✝⁶ : IsScalarTower R M X
inst✝⁵ : SMul R' X
inst✝⁴ : SMul R' M
inst✝³ : IsScalarTower R' M M
inst✝² : IsScalarTower R' M X
inst✝¹ : SMul R R'
inst✝ : IsScalarTower R R' M
r : R
x : X
⊢ r • (x /ₒ 1) = r • x /ₒ 1
state_after: no goals
tactic: rw [← smul_one_oreDiv_one_smul, smul_div_one, smul_assoc, one_smul]
Theorem: List.zipWith_rotate_one
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
β : Type u_1
f : α → α → β
x y : α
l : List α
⊢ zipWith f (x :: y :: l) ((x :: y :: l).rotate 1) = f x y :: zipWith f (y :: l) (l ++ [x])
state_after: no goals
tactic: simp
Theorem: Ultrafilter.eq_pure_of_finite_mem
File: Mathlib/Order/Filter/Ultrafilter.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
h : s.Finite
h' : s ∈ f
⊢ ∃ x ∈ s, f = pure x
state_after: α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
h : s.Finite
h' : ⋃ x ∈ s, {x} ∈ f
⊢ ∃ x ∈ s, f = pure x
tactic: rw [← biUnion_of_singleton s] at h'
state_before: α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
h : s.Finite
h' : ⋃ x ∈ s, {x} ∈ f
⊢ ∃ x ∈ s, f = pure x
state_after: case intro.intro
α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
h : s.Finite
h' : ⋃ x ∈ s, {x} ∈ f
a : α
has : a ∈ s
haf : {a} ∈ f
⊢ ∃ x ∈ s, f = pure x
tactic: rcases (Ultrafilter.finite_biUnion_mem_iff h).mp h' with ⟨a, has, haf⟩
state_before: case intro.intro
α : Type u
β : Type v
γ : Type u_1
f g : Ultrafilter α
s t : Set α
p q : α → Prop
h : s.Finite
h' : ⋃ x ∈ s, {x} ∈ f
a : α
has : a ∈ s
haf : {a} ∈ f
⊢ ∃ x ∈ s, f = pure x
state_after: no goals
tactic: exact ⟨a, has, eq_of_le (Filter.le_pure_iff.2 haf)⟩
Theorem: ComplexShape.ε_zero
File: Mathlib/Algebra/Homology/ComplexShapeSigns.lean

Proof steps:
state_before: I₁ : Type u_1
I₂ : Type u_2
I₁₂ : Type u_3
c₁ : ComplexShape I₁
c₂ : ComplexShape I₂
c₁₂ : ComplexShape I₁₂
inst✝² : TotalComplexShape c₁ c₂ c₁₂
I : Type u_4
inst✝¹ : AddMonoid I
c : ComplexShape I
inst✝ : c.TensorSigns
⊢ c.ε 0 = 1
state_after: no goals
tactic: apply MonoidHom.map_one
Theorem: List.rdropWhile_singleton
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
x : α
⊢ rdropWhile p [x] = if p x = true then [] else [x]
state_after: no goals
tactic: rw [← nil_append [x], rdropWhile_concat, rdropWhile_nil]
Theorem: algebraicIndependent_of_finite
File: Mathlib/RingTheory/AlgebraicIndependent.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
R : Type u_3
K : Type u_4
A : Type u_5
A' : Type u_6
A'' : Type u_7
V : Type u
V' : Type u_8
x : ι → A
inst✝⁶ : CommRing R
inst✝⁵ : CommRing A
inst✝⁴ : CommRing A'
inst✝³ : CommRing A''
inst✝² : Algebra R A
inst✝¹ : Algebra R A'
inst✝ : Algebra R A''
a b : R
s : Set A
H : ∀ t ⊆ s, t.Finite → AlgebraicIndependent R Subtype.val
p : MvPolynomial A R
hp : p ∈ supported R s
⊢ p ∈ supported R ↑p.vars
state_after: no goals
tactic: simp
Theorem: InitialSeg.acc
File: Mathlib/Order/InitialSeg.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a : α
⊢ Acc r a → Acc s (f a)
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (f y)
b : β
hb : s b (f a)
⊢ Acc s b
tactic: refine fun h => Acc.recOn h fun a _ ha => Acc.intro _ fun b hb => ?_
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (f y)
b : β
hb : s b (f a)
⊢ Acc s b
state_after: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (f y)
a' : α
hb : s (f a') (f a)
⊢ Acc s (f a')
tactic: obtain ⟨a', rfl⟩ := f.init hb
state_before: case intro
α : Type u_1
β : Type u_2
γ : Type u_3
r : α → α → Prop
s : β → β → Prop
t : γ → γ → Prop
f : r ≼i s
a✝ : α
h : Acc r a✝
a : α
x✝ : ∀ (y : α), r y a → Acc r y
ha : ∀ (y : α), r y a → Acc s (f y)
a' : α
hb : s (f a') (f a)
⊢ Acc s (f a')
state_after: no goals
tactic: exact ha _ (f.map_rel_iff.mp hb)
Theorem: hasProd_prod
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f✝ g : β → α
a✝ b : α
s✝ : Finset β
inst✝ : ContinuousMul α
f : γ → β → α
a : γ → α
s : Finset γ
⊢ (∀ i ∈ s, HasProd (f i) (a i)) → HasProd (fun b => ∏ i ∈ s, f i b) (∏ i ∈ s, a i)
state_after: no goals
tactic: classical
  exact Finset.induction_on s (by simp only [hasProd_one, prod_empty, forall_true_iff]) <| by
    -- Porting note: with some help, `simp` used to be able to close the goal
    simp (config := { contextual := true }) only [mem_insert, forall_eq_or_imp, not_false_iff,
      prod_insert, and_imp]
    exact fun x s _ IH hx h ↦ hx.mul (IH h)
Theorem: FirstOrder.Language.Formula.realize_rel
File: Mathlib/ModelTheory/Semantics.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n : ℕ
φ ψ : L.Formula α
v : α → M
k : ℕ
R : L.Relations k
ts : Fin k → L.Term α
⊢ (RelMap R fun i => Term.realize (Sum.elim v default) (Term.relabel Sum.inl (ts i))) ↔
    RelMap R fun i => Term.realize v (ts i)
state_after: no goals
tactic: simp
Theorem: Matroid.closure_insert_eq_of_mem_closure
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
he : e ∈ M.closure X
⊢ M.closure (insert e X) = M.closure X
state_after: no goals
tactic: rw [← closure_insert_closure_eq_closure_insert, insert_eq_of_mem he, closure_closure]
Theorem: PFun.mem_dom
File: Mathlib/Data/PFun.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ι : Type u_6
f : α →. β
x : α
⊢ x ∈ f.Dom ↔ ∃ y, y ∈ f x
state_after: no goals
tactic: simp [Dom, Part.dom_iff_mem]
Theorem: Real.Angle.abs_sin_eq_of_two_nsmul_eq
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Angle.lean

Proof steps:
state_before: θ ψ : Angle
h : 2 • θ = 2 • ψ
⊢ |θ.sin| = |ψ.sin|
state_after: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ |θ.sin| = |ψ.sin|
tactic: rw [two_nsmul_eq_iff] at h
state_before: θ ψ : Angle
h : θ = ψ ∨ θ = ψ + ↑π
⊢ |θ.sin| = |ψ.sin|
state_after: case inl
θ : Angle
⊢ |θ.sin| = |θ.sin|

case inr
ψ : Angle
⊢ |(ψ + ↑π).sin| = |ψ.sin|
tactic: rcases h with (rfl | rfl)
Theorem: LinearIndependent.union_of_quotient
File: Mathlib/LinearAlgebra/Dimension/Constructions.lean

Proof steps:
state_before: R S : Type u
M : Type v
M'✝ : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁷ : Ring R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'✝
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'✝
inst✝ : Module R M₁
M' : Submodule R M
s : Set M
hs : s ⊆ ↑M'
hs' : LinearIndependent (ι := ↑s) R Subtype.val
t : Set M
ht : LinearIndependent (ι := ↑t) R (Submodule.Quotient.mk ∘ Subtype.val)
⊢ LinearIndependent (ι := ↑(s ∪ t)) R Subtype.val
state_after: R S : Type u
M : Type v
M'✝ : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁷ : Ring R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'✝
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'✝
inst✝ : Module R M₁
M' : Submodule R M
s : Set M
hs : s ⊆ ↑M'
hs' : LinearIndependent (ι := ↑s) R Subtype.val
t : Set M
ht : LinearIndependent (ι := ↑t) R (Submodule.Quotient.mk ∘ Subtype.val)
⊢ range (Sum.elim (fun x => ↑((s.embeddingOfSubset (↑M') hs) x)) Subtype.val) = s ∪ t
tactic: refine (LinearIndependent.sum_elim_of_quotient (f := Set.embeddingOfSubset s M' hs)
    (of_comp M'.subtype (by simpa using hs')) Subtype.val ht).to_subtype_range' ?_
state_before: R S : Type u
M : Type v
M'✝ : Type v'
M₁ : Type v
ι : Type w
ι' : Type w'
η : Type u₁'
φ : η → Type u_1
inst✝⁷ : Ring R
inst✝⁶ : CommRing S
inst✝⁵ : AddCommGroup M
inst✝⁴ : AddCommGroup M'✝
inst✝³ : AddCommGroup M₁
inst✝² : Module R M
inst✝¹ : Module R M'✝
inst✝ : Module R M₁
M' : Submodule R M
s : Set M
hs : s ⊆ ↑M'
hs' : LinearIndependent (ι := ↑s) R Subtype.val
t : Set M
ht : LinearIndependent (ι := ↑t) R (Submodule.Quotient.mk ∘ Subtype.val)
⊢ range (Sum.elim (fun x => ↑((s.embeddingOfSubset (↑M') hs) x)) Subtype.val) = s ∪ t
state_after: no goals
tactic: simp only [embeddingOfSubset_apply_coe, Sum.elim_range, Subtype.range_val]
Theorem: QuaternionAlgebra.self_add_star
File: Mathlib/Algebra/Quaternion.lean

Proof steps:
state_before: S : Type u_1
T : Type u_2
R : Type u_3
inst✝ : CommRing R
c₁ c₂ r x y z : R
a b c : ℍ[R,c₁,c₂]
⊢ a + star a = 2 * ↑a.re
state_after: no goals
tactic: simp only [self_add_star', two_mul, coe_add]
Theorem: Subgroup.sup_eq_closure_mul
File: Mathlib/Algebra/Group/Subgroup/Pointwise.lean

Proof steps:
state_before: α : Type u_1
G : Type u_2
A : Type u_3
S : Type u_4
inst✝¹ : Group G
inst✝ : AddGroup A
s : Set G
H K : Subgroup G
⊢ closure ↑H ⊔ closure ↑K ≤ H ⊔ K
state_after: no goals
tactic: rw [closure_eq, closure_eq]
Theorem: AlgebraicGeometry.localRingHom_comp_stalkIso
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑S
x : ↑R
⊢ (((stalkIso (↑R) ((PrimeSpectrum.comap f) p)).inv ≫ PresheafedSpace.Hom.stalkMap (Spec.sheafedSpaceMap f) p) ≫
        (stalkIso (↑S) p).hom)
      ((algebraMap (↑R) (Localization.AtPrime ((PrimeSpectrum.comap f) p).asIdeal)) x) =
    (algebraMap (↑S) (Localization.AtPrime p.asIdeal)) (f x)
state_after: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑S
x : ↑R
⊢ ((localizationToStalk (↑R) ((PrimeSpectrum.comap f) p) ≫ PresheafedSpace.Hom.stalkMap (Spec.sheafedSpaceMap f) p) ≫
        stalkToFiberRingHom (↑S) p)
      ((algebraMap (↑R) (Localization.AtPrime ((PrimeSpectrum.comap f) p).asIdeal)) x) =
    (algebraMap (↑S) (Localization.AtPrime p.asIdeal)) (f x)
tactic: rw [stalkIso_hom, stalkIso_inv]
state_before: R S : CommRingCat
f : R ⟶ S
p : PrimeSpectrum ↑S
x : ↑R
⊢ ((localizationToStalk (↑R) ((PrimeSpectrum.comap f) p) ≫ PresheafedSpace.Hom.stalkMap (Spec.sheafedSpaceMap f) p) ≫
        stalkToFiberRingHom (↑S) p)
      ((algebraMap (↑R) (Localization.AtPrime ((PrimeSpectrum.comap f) p).asIdeal)) x) =
    (algebraMap (↑S) (Localization.AtPrime p.asIdeal)) (f x)
state_after: no goals
tactic: erw [comp_apply, comp_apply, localizationToStalk_of, stalkMap_toStalk_apply f p x,
            stalkToFiberRingHom_toStalk]
Theorem: Pi.support_single_disjoint
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: A : Type u_1
B : Type u_2
inst✝¹ : DecidableEq A
inst✝ : One B
a : A
b b' : B
hb : b ≠ 1
hb' : b' ≠ 1
i j : A
⊢ Disjoint (mulSupport (mulSingle i b)) (mulSupport (mulSingle j b')) ↔ i ≠ j
state_after: no goals
tactic: rw [mulSupport_mulSingle_of_ne hb, mulSupport_mulSingle_of_ne hb', disjoint_singleton]
Theorem: Matrix.blockDiagonal'_conjTranspose
File: Mathlib/Data/Matrix/Block.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α✝ : Type u_12
β : Type u_13
inst✝⁴ : DecidableEq o
inst✝³ : Zero α✝
inst✝² : Zero β
α : Type u_14
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : (i : o) → Matrix (m' i) (n' i) α
⊢ (blockDiagonal' M)ᴴ = blockDiagonal' fun k => (M k)ᴴ
state_after: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α✝ : Type u_12
β : Type u_13
inst✝⁴ : DecidableEq o
inst✝³ : Zero α✝
inst✝² : Zero β
α : Type u_14
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : (i : o) → Matrix (m' i) (n' i) α
⊢ (blockDiagonal' fun k => (M k)ᵀ).map star = blockDiagonal' fun k => (M k)ᵀ.map star
tactic: simp only [conjTranspose, blockDiagonal'_transpose]
state_before: l : Type u_1
m : Type u_2
n : Type u_3
o : Type u_4
p : Type u_5
q : Type u_6
m' : o → Type u_7
n' : o → Type u_8
p' : o → Type u_9
R : Type u_10
S : Type u_11
α✝ : Type u_12
β : Type u_13
inst✝⁴ : DecidableEq o
inst✝³ : Zero α✝
inst✝² : Zero β
α : Type u_14
inst✝¹ : AddMonoid α
inst✝ : StarAddMonoid α
M : (i : o) → Matrix (m' i) (n' i) α
⊢ (blockDiagonal' fun k => (M k)ᵀ).map star = blockDiagonal' fun k => (M k)ᵀ.map star
state_after: no goals
tactic: exact blockDiagonal'_map _ star (star_zero α)
Theorem: SimpleGraph.colorable_iff_exists_bdd_nat_coloring
File: Mathlib/Combinatorics/SimpleGraph/Coloring.lean

Proof steps:
state_before: V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n : ℕ
⊢ G.Colorable n ↔ ∃ C, ∀ (v : V), C v < n
state_after: case mp
V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n : ℕ
⊢ G.Colorable n → ∃ C, ∀ (v : V), C v < n

case mpr
V : Type u
G : SimpleGraph V
n✝ : ℕ
α : Type u_1
β : Type u_2
C : G.Coloring α
n : ℕ
⊢ (∃ C, ∀ (v : V), C v < n) → G.Colorable n
tactic: constructor