ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: List.cyclicPermutations_rotate
File: Mathlib/Data/List/Rotate.lean

Proof steps:
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations = l.cyclicPermutations.rotate k
state_after: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations.get ⟨n, hn⟩ = (l.cyclicPermutations.rotate k).get ⟨n, hn'⟩
tactic: refine ext_get this fun n hn hn' => ?_
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ (l.rotate k).cyclicPermutations.get ⟨n, hn⟩ = (l.cyclicPermutations.rotate k).get ⟨n, hn'⟩
state_after: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ l.rotate ((↑⟨n, hn⟩ + k) % l.length) = l.cyclicPermutations.get ⟨(↑⟨n, hn'⟩ + k) % l.cyclicPermutations.length, ⋯⟩
tactic: rw [get_rotate, get_cyclicPermutations, rotate_rotate, ← rotate_mod, Nat.add_comm]
state_before: α : Type u
l✝ l' l : List α
k : ℕ
this : (l.rotate k).cyclicPermutations.length = (l.cyclicPermutations.rotate k).length
n : ℕ
hn : n < (l.rotate k).cyclicPermutations.length
hn' : n < (l.cyclicPermutations.rotate k).length
⊢ l.rotate ((↑⟨n, hn⟩ + k) % l.length) = l.cyclicPermutations.get ⟨(↑⟨n, hn'⟩ + k) % l.cyclicPermutations.length, ⋯⟩
state_after: no goals
tactic: cases l <;> simp
Theorem: CategoryTheory.ComposableArrows.ext₁
File: Mathlib/CategoryTheory/ComposableArrows.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
⊢ F.map' 0 1 ⋯ ⋯ ≫ (eqToIso right).hom = (eqToIso left).hom ≫ G.map' 0 1 ⋯ ⋯
state_after: no goals
tactic: simp [map'_eq_hom₁, w]
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
i : Fin (1 + 1)
⊢ F.obj i = G.obj i
state_after: no goals
tactic: fin_cases i <;> assumption
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
n m : ℕ
F✝ G✝ : ComposableArrows C n
F G : ComposableArrows C 1
left : F.left = G.left
right : F.right = G.right
w : F.hom = eqToHom left ≫ G.hom ≫ eqToHom ⋯
i : Fin (1 + 1)
⊢ (isoMk₁ (eqToIso left) (eqToIso right) ⋯).hom.app i = eqToHom ⋯
state_after: no goals
tactic: fin_cases i <;> rfl
Theorem: Polynomial.leadingCoeff_map'
File: Mathlib/Algebra/Polynomial/Monic.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).leadingCoeff = f p.leadingCoeff
state_after: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)
tactic: unfold leadingCoeff
state_before: R : Type u
S : Type v
a b : R
m n : ℕ
ι : Type y
inst✝¹ : Semiring R
inst✝ : Semiring S
f : R →+* S
hf : Injective ⇑f
p : R[X]
⊢ (map f p).coeff (map f p).natDegree = f (p.coeff p.natDegree)
state_after: no goals
tactic: rw [coeff_map, natDegree_map_eq_of_injective hf p]
Theorem: isLUB_biSup
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✝ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
s : Set β
f : β → α
⊢ IsLUB (f '' s) (⨆ x ∈ s, f x)
state_after: no goals
tactic: simpa only [range_comp, Subtype.range_coe, iSup_subtype'] using
    @isLUB_iSup α s _ (f ∘ fun x => (x : β))
Theorem: List.filter_beq'
File: .lake/packages/batteries/Batteries/Data/List/Count.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
l : List α
a : α
⊢ filter (fun x => a == x) l = replicate (count a l) a
state_after: no goals
tactic: simpa only [eq_comm (b := a)] using filter_eq l a
Theorem: _private.«.lake».packages.batteries.Batteries.Data.List.Init.Attach.0.List.pmap_eq_pmapImpl
File: .lake/packages/batteries/Batteries/Data/List/Init/Attach.lean

Proof steps:
state_before: ⊢ @pmap = @List.pmapImpl
state_after: case h.h.h.h.h.h
α : Type u_2
β : Type u_1
p : α → Prop
f : (a : α) → p a → β
L : List α
h' : ∀ (a : α), a ∈ L → p a
⊢ pmap f L h' = List.pmapImpl f L h'
tactic: funext α β p f L h'
state_before: case h.h.h.h.h.h
α : Type u_2
β : Type u_1
p : α → Prop
f : (a : α) → p a → β
L : List α
h' : ∀ (a : α), a ∈ L → p a
⊢ pmap f L h' = List.pmapImpl f L h'
state_after: no goals
tactic: exact go L h'
Theorem: HurwitzZeta.sinZeta_two_mul_nat_add_one
File: Mathlib/NumberTheory/LSeries/HurwitzZetaValues.lean

Proof steps:
state_before: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ sinZeta (↑x) (2 * ↑k + 1) =
    (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k + 1)))
state_after: k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ ∑' (b : ℕ), ↑(Real.sin (2 * π * x * ↑b)) / ↑b ^ (2 * ↑k + 1) =
    (-1) ^ (k + 1) * (2 * ↑π) ^ (2 * k + 1) / 2 / ↑(2 * k + 1)! *
      Polynomial.eval (↑x) (Polynomial.map (algebraMap ℚ ℂ) (Polynomial.bernoulli (2 * k + 1)))

k : ℕ
x : ℝ
hk : k ≠ 0
hx : x ∈ Icc 0 1
⊢ 1 < (2 * ↑k + 1).re
tactic: rw [← (hasSum_nat_sinZeta x (?_ : 1 < re (2 * k + 1))).tsum_eq]
Theorem: Real.iSup_mul_of_nonpos
File: Mathlib/Data/Real/Pointwise.lean

Proof steps:
state_before: ι : Sort u_1
α : Type u_2
inst✝ : LinearOrderedField α
r : ℝ
ha : r ≤ 0
f : ι → ℝ
⊢ (⨆ i, f i) * r = ⨅ i, f i * r
state_after: no goals
tactic: simp only [Real.mul_iSup_of_nonpos ha, mul_comm]
Theorem: MeasureTheory.eLpNorm'_zero'
File: Mathlib/MeasureTheory/Function/LpSeminorm/Basic.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
⊢ eLpNorm' 0 q μ = 0
state_after: case inl
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
hq0 : 0 ≤ q
⊢ eLpNorm' 0 q μ = 0

case inr
α : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
m m0 : MeasurableSpace α
p : ℝ≥0∞
q : ℝ
μ ν : Measure α
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedAddCommGroup G
hq0_ne : q ≠ 0
hμ : μ ≠ 0
hq_neg : q < 0
⊢ eLpNorm' 0 q μ = 0
tactic: rcases le_or_lt 0 q with hq0 | hq_neg
Theorem: map_inv₀
File: Mathlib/Algebra/GroupWithZero/Units/Lemmas.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝⁴ : MonoidWithZero M₀
inst✝³ : GroupWithZero G₀
inst✝² : GroupWithZero G₀'
inst✝¹ : FunLike F G₀ G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
⊢ f a⁻¹ = (f a)⁻¹
state_after: case pos
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝⁴ : MonoidWithZero M₀
inst✝³ : GroupWithZero G₀
inst✝² : GroupWithZero G₀'
inst✝¹ : FunLike F G₀ G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
h : a = 0
⊢ f a⁻¹ = (f a)⁻¹

case neg
α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝⁴ : MonoidWithZero M₀
inst✝³ : GroupWithZero G₀
inst✝² : GroupWithZero G₀'
inst✝¹ : FunLike F G₀ G₀'
inst✝ : MonoidWithZeroHomClass F G₀ G₀'
f : F
a b : G₀
h : ¬a = 0
⊢ f a⁻¹ = (f a)⁻¹
tactic: by_cases h : a = 0
Theorem: iteratedDeriv_one
File: Mathlib/Analysis/Calculus/IteratedDeriv/Defs.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x : 𝕜
⊢ iteratedDeriv 1 f = deriv f
state_after: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv 1 f x = deriv f x
tactic: ext x
state_before: case h
𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedSpace 𝕜 E
n : ℕ
f : 𝕜 → F
s : Set 𝕜
x✝ x : 𝕜
⊢ iteratedDeriv 1 f x = deriv f x
state_after: no goals
tactic: simp [iteratedDeriv]
Theorem: CategoryTheory.Functor.LeftExtension.IsPointwiseLeftKanExtensionAt.isIso_hom_app
File: Mathlib/CategoryTheory/Functor/KanExtension/Pointwise.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
H : Type u_3
inst✝⁴ : Category.{u_4, u_1} C
inst✝³ : Category.{u_5, u_2} D
inst✝² : Category.{u_6, u_3} H
L : C ⥤ D
F : C ⥤ H
E : L.LeftExtension F
X : C
h : E.IsPointwiseLeftKanExtensionAt (L.obj X)
inst✝¹ : L.Full
inst✝ : L.Faithful
⊢ IsIso (E.hom.app X)
state_after: no goals
tactic: simpa using h.isIso_ι_app_of_isTerminal _ CostructuredArrow.mkIdTerminal
Theorem: MeasureTheory.Content.outerMeasure_preimage
File: Mathlib/MeasureTheory/Measure/Content.lean

Proof steps:
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ μ.outerMeasure (⇑f ⁻¹' A) = μ.outerMeasure A
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ ∀ (s : Set G) (hs : IsOpen s),
    μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
tactic: refine inducedOuterMeasure_preimage _ μ.innerContent_iUnion_nat μ.innerContent_mono _
    (fun _ => f.isOpen_preimage) ?_
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A : Set G
⊢ ∀ (s : Set G) (hs : IsOpen s),
    μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
state_after: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A s : Set G
hs : IsOpen s
⊢ μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
tactic: intro s hs
state_before: G : Type w
inst✝¹ : TopologicalSpace G
μ : Content G
inst✝ : R1Space G
f : G ≃ₜ G
h : ∀ ⦃K : Compacts G⦄, (fun s => ↑(μ.toFun s)) (Compacts.map ⇑f ⋯ K) = (fun s => ↑(μ.toFun s)) K
A s : Set G
hs : IsOpen s
⊢ μ.innerContent { carrier := ⇑f.toEquiv ⁻¹' s, is_open' := ⋯ } = μ.innerContent { carrier := s, is_open' := hs }
state_after: no goals
tactic: convert μ.innerContent_comap f h ⟨s, hs⟩
Theorem: IsLocalization.isLocalization_isLocalization_atPrime_isLocalization
File: Mathlib/RingTheory/Localization/LocalizationLocalization.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ IsLocalization.AtPrime T (Ideal.comap (algebraMap R S) p)
state_after: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ ∀ (x : S), IsUnit x → x ∈ p.primeCompl
tactic: apply localization_localization_isLocalization_of_has_all_units M p.primeCompl T
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
⊢ ∀ (x : S), IsUnit x → x ∈ p.primeCompl
state_after: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
x : S
hx : IsUnit x
hx' : x ∈ ↑p
⊢ False
tactic: intro x hx hx'
state_before: R : Type u_1
inst✝⁹ : CommSemiring R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommSemiring S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommSemiring P
N : Submonoid S
T : Type u_4
inst✝⁵ : CommSemiring T
inst✝⁴ : Algebra R T
inst✝³ : Algebra S T
inst✝² : IsScalarTower R S T
inst✝¹ : IsLocalization M S
p : Ideal S
Hp : p.IsPrime
inst✝ : IsLocalization.AtPrime T p
x : S
hx : IsUnit x
hx' : x ∈ ↑p
⊢ False
state_after: no goals
tactic: exact (Hp.1 : ¬_) (p.eq_top_of_isUnit_mem hx' hx)
Theorem: CompositionSeries.Equivalent.symm
File: Mathlib/Order/JordanHolder.lean

Proof steps:
state_before: X : Type u
inst✝¹ : Lattice X
inst✝ : JordanHolderLattice X
s₁ s₂ : CompositionSeries X
h : s₁.Equivalent s₂
i : Fin s₂.length
⊢ Iso (s₁.toFun ((Exists.choose h).symm i).castSucc, s₁.toFun ((Exists.choose h).symm i).succ)
    (s₂.toFun i.castSucc, s₂.toFun i.succ)
state_after: no goals
tactic: simpa using h.choose_spec (h.choose.symm i)
Theorem: CategoryTheory.Iso.map_inv_hom_id_eval
File: Mathlib/CategoryTheory/GradedObject.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
E : Type u_3
J : Type u_4
inst✝² : Category.{u_5, u_1} C
inst✝¹ : Category.{u_6, u_2} D
inst✝ : Category.{?u.11066, u_3} E
X Y : GradedObject J C
e : X ≅ Y
F : C ⥤ D
j : J
⊢ F.map (e.inv j) ≫ F.map (e.hom j) = 𝟙 (F.obj (Y j))
state_after: no goals
tactic: rw [← F.map_comp, ← GradedObject.categoryOfGradedObjects_comp, e.inv_hom_id,
    GradedObject.categoryOfGradedObjects_id, Functor.map_id]
Theorem: FunctionField.inftyValuation_of_nonzero
File: Mathlib/NumberTheory/FunctionField.lean

Proof steps:
state_before: Fq F : Type
inst✝² : Field Fq
inst✝¹ : Field F
inst✝ : DecidableEq (RatFunc Fq)
x : RatFunc Fq
hx : x ≠ 0
⊢ inftyValuationDef Fq x = ↑(Multiplicative.ofAdd x.intDegree)
state_after: no goals
tactic: rw [inftyValuationDef, if_neg hx]
Theorem: CategoryTheory.Bifunctor.map_id_comp
File: Mathlib/CategoryTheory/Products/Bifunctor.lean

Proof steps:
state_before: C : Type u₁
D : Type u₂
E : Type u₃
inst✝² : Category.{v₁, u₁} C
inst✝¹ : Category.{v₂, u₂} D
inst✝ : Category.{v₃, u₃} E
F : C × D ⥤ E
W : C
X Y Z : D
f : X ⟶ Y
g : Y ⟶ Z
⊢ F.map (𝟙 W, f ≫ g) = F.map (𝟙 W, f) ≫ F.map (𝟙 W, g)
state_after: no goals
tactic: rw [← Functor.map_comp, prod_comp, Category.comp_id]
Theorem: Relation.reflTransGen_iff_eq
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
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ ReflTransGen r a b ↔ b = a
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) ↔ b = a
tactic: rw [cases_head_iff]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
h : ∀ (b : α), ¬r a b
⊢ (a = b ∨ ∃ c, r a c ∧ ReflTransGen r c b) ↔ b = a
state_after: no goals
tactic: simp [h, eq_comm]
Theorem: eq_div_of_mul_eq'
File: Mathlib/Algebra/Group/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G : Type u_3
M : Type u_4
inst✝ : Group G
a b c d : G
n : ℤ
h : a * c = b
⊢ a = b / c
state_after: no goals
tactic: simp [← h]
Theorem: Polynomial.eval₂_one
File: Mathlib/Algebra/Polynomial/Eval.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
a b : R
m n : ℕ
inst✝¹ : Semiring R
p q r : R[X]
inst✝ : Semiring S
f : R →+* S
x : S
⊢ eval₂ f x 1 = 1
state_after: no goals
tactic: rw [← C_1, eval₂_C, f.map_one]
Theorem: Filter.lift_iInf_of_directed
File: Mathlib/Order/Filter/Lift.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Filter β
hf : Directed (fun x x_1 => x ≥ x_1) f
hg : Monotone g
s : Set β
⊢ s ∈ (iInf f).lift g → s ∈ ⨅ i, (f i).lift g
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Filter β
hf : Directed (fun x x_1 => x ≥ x_1) f
hg : Monotone g
s : Set β
⊢ ∀ (x : Set α) (x_1 : ι), x ∈ f x_1 → s ∈ g x → s ∈ ⨅ i, (f i).lift g
tactic: simp only [mem_lift_sets hg, exists_imp, and_imp, mem_iInf_of_directed hf]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
ι : Sort u_4
f✝ f₁ f₂ : Filter α
g✝ g₁ g₂ : Set α → Filter β
inst✝ : Nonempty ι
f : ι → Filter α
g : Set α → Filter β
hf : Directed (fun x x_1 => x ≥ x_1) f
hg : Monotone g
s : Set β
⊢ ∀ (x : Set α) (x_1 : ι), x ∈ f x_1 → s ∈ g x → s ∈ ⨅ i, (f i).lift g
state_after: no goals
tactic: exact fun t i ht hs => mem_iInf_of_mem i <| mem_lift ht hs
Theorem: CategoryTheory.Iso.map_hom_inv_id
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
X✝ Y✝ Z : C
D : Type u_1
E : Type u_2
inst✝¹ : Category.{u_3, u_1} D
inst✝ : Category.{?u.30099, u_2} E
X Y : C
e : X ≅ Y
F : C ⥤ D
⊢ F.map e.hom ≫ F.map e.inv = 𝟙 (F.obj X)
state_after: no goals
tactic: rw [← F.map_comp, e.hom_inv_id, F.map_id]
Theorem: Finset.max_erase_ne_self
File: Mathlib/Data/Finset/Lattice.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
⊢ (s.erase x).max ≠ ↑x
state_after: case pos
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
s0 : (s.erase x).Nonempty
⊢ (s.erase x).max ≠ ↑x

case neg
F : Type u_1
α : Type u_2
β : Type u_3
γ : Type u_4
ι : Type u_5
κ : Type u_6
inst✝ : LinearOrder α
s✝ : Finset α
H : s✝.Nonempty
x : α
s : Finset α
s0 : ¬(s.erase x).Nonempty
⊢ (s.erase x).max ≠ ↑x
tactic: by_cases s0 : (s.erase x).Nonempty
Theorem: Set.subset_insert_diff_singleton
File: Mathlib/Data/Set/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι : Sort x
a b : α
s✝ s₁ s₂ t t₁ t₂ u : Set α
x : α
s : Set α
⊢ s ⊆ insert x (s \ {x})
state_after: no goals
tactic: rw [← diff_singleton_subset_iff]
Theorem: Matrix.invOf_fromBlocks₁₁_eq
File: Mathlib/LinearAlgebra/Matrix/SchurComplement.lean

Proof steps:
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible (D - C * ⅟A * B)
inst✝ : Invertible (fromBlocks A B C D)
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟A + ⅟A * B * ⅟(D - C * ⅟A * B) * C * ⅟A) (-(⅟A * B * ⅟(D - C * ⅟A * B)))
      (-(⅟(D - C * ⅟A * B) * C * ⅟A)) ⅟(D - C * ⅟A * B)
state_after: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible (D - C * ⅟A * B)
inst✝ : Invertible (fromBlocks A B C D)
this : Invertible (fromBlocks A B C D) := A.fromBlocks₁₁Invertible B C D
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟A + ⅟A * B * ⅟(D - C * ⅟A * B) * C * ⅟A) (-(⅟A * B * ⅟(D - C * ⅟A * B)))
      (-(⅟(D - C * ⅟A * B) * C * ⅟A)) ⅟(D - C * ⅟A * B)
tactic: letI := fromBlocks₁₁Invertible A B C D
state_before: l : Type u_1
m : Type u_2
n : Type u_3
α : Type u_4
inst✝⁹ : Fintype l
inst✝⁸ : Fintype m
inst✝⁷ : Fintype n
inst✝⁶ : DecidableEq l
inst✝⁵ : DecidableEq m
inst✝⁴ : DecidableEq n
inst✝³ : CommRing α
A : Matrix m m α
B : Matrix m n α
C : Matrix n m α
D : Matrix n n α
inst✝² : Invertible A
inst✝¹ : Invertible (D - C * ⅟A * B)
inst✝ : Invertible (fromBlocks A B C D)
this : Invertible (fromBlocks A B C D) := A.fromBlocks₁₁Invertible B C D
⊢ ⅟(fromBlocks A B C D) =
    fromBlocks (⅟A + ⅟A * B * ⅟(D - C * ⅟A * B) * C * ⅟A) (-(⅟A * B * ⅟(D - C * ⅟A * B)))
      (-(⅟(D - C * ⅟A * B) * C * ⅟A)) ⅟(D - C * ⅟A * B)
state_after: no goals
tactic: convert (rfl : ⅟ (fromBlocks A B C D) = _)
Theorem: Real.log_sqrt
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

Proof steps:
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ log √x = log x / 2
state_after: x✝ y x : ℝ
hx : 0 ≤ x
⊢ 2 ≠ 0
tactic: rw [eq_div_iff, mul_comm, ← Nat.cast_two, ← log_pow, sq_sqrt hx]
state_before: x✝ y x : ℝ
hx : 0 ≤ x
⊢ 2 ≠ 0
state_after: no goals
tactic: exact two_ne_zero
Theorem: CategoryTheory.Limits.limitOpIsoOpColimit_hom_comp_ι
File: Mathlib/CategoryTheory/Limits/IndYoneda.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{u₂, u₁} C
I : Type v₁
inst✝¹ : Category.{v₂, v₁} I
F : I ⥤ C
inst✝ : HasColimit F
i : I
⊢ (limitOpIsoOpColimit F).hom ≫ (colimit.ι F i).op = limit.π F.op (op i)
state_after: no goals
tactic: rw [← limitOpIsoOpColimit_inv_comp_π, ← Category.assoc, Iso.hom_inv_id, Category.id_comp]