ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: MeasureTheory.le_hitting_of_exists
File: Mathlib/Probability/Process/HittingTime.lean

Proof steps:
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ n ≤ hitting u s n m ω
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ n ≤ m
tactic: refine le_hitting ?_ ω
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
⊢ n ≤ m
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
h : ¬n ≤ m
⊢ False
tactic: by_contra h
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ Set.Icc n m, u j ω ∈ s
h : ¬n ≤ m
⊢ False
state_after: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ ∅, u j ω ∈ s
h : ¬n ≤ m
⊢ False
tactic: rw [Set.Icc_eq_empty_of_lt (not_le.mp h)] at h_exists
state_before: Ω : Type u_1
β : Type u_2
ι : Type u_3
m✝ : MeasurableSpace Ω
inst✝ : ConditionallyCompleteLinearOrder ι
u : ι → Ω → β
s : Set β
n i : ι
ω : Ω
m : ι
h_exists : ∃ j ∈ ∅, u j ω ∈ s
h : ¬n ≤ m
⊢ False
state_after: no goals
tactic: simp at h_exists
Theorem: GradedTensorProduct.tmul_coe_mul_one_tmul
File: Mathlib/LinearAlgebra/TensorProduct/Graded/Internal.lean

Proof steps:
state_before: case h.e'_3.h.e'_16
R : Type u_1
ι : Type u_2
A : Type u_3
B : Type u_4
inst✝⁹ : CommSemiring ι
inst✝⁸ : Module ι (Additive ℤˣ)
inst✝⁷ : DecidableEq ι
inst✝⁶ : CommRing R
inst✝⁵ : Ring A
inst✝⁴ : Ring B
inst✝³ : Algebra R A
inst✝² : Algebra R B
𝒜 : ι → Submodule R A
ℬ : ι → Submodule R B
inst✝¹ : GradedAlgebra 𝒜
inst✝ : GradedAlgebra ℬ
j₁ : ι
a₁ : A
b₁ : ↥(ℬ j₁)
b₂ : B
⊢ a₁ = a₁ * ↑GradedMonoid.GOne.one
state_after: no goals
tactic: rw [SetLike.coe_gOne, mul_one]
Theorem: Finset.exists_ne_of_one_lt_card
File: Mathlib/Data/Finset/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a : α
⊢ ∃ b ∈ s, b ≠ a
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
⊢ ∃ b ∈ s, b ≠ a
tactic: obtain ⟨x, hx, y, hy, hxy⟩ := Finset.one_lt_card.mp hs
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
⊢ ∃ b ∈ s, b ≠ a
state_after: case pos
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
ha : y = a
⊢ ∃ b ∈ s, b ≠ a

case neg
α : Type u_1
β : Type u_2
R : Type u_3
s t u : Finset α
f : α → β
n : ℕ
hs : 1 < s.card
a x : α
hx : x ∈ s
y : α
hy : y ∈ s
hxy : x ≠ y
ha : ¬y = a
⊢ ∃ b ∈ s, b ≠ a
tactic: by_cases ha : y = a
Theorem: ComplexShape.Embedding.BoundaryLE.not_mem
File: Mathlib/Algebra/Homology/Embedding/Boundary.lean

Proof steps:
state_before: ι : Type u_1
ι' : Type u_2
c : ComplexShape ι
c' : ComplexShape ι'
e : c.Embedding c'
j : ι
hj : e.BoundaryLE j
k' : ι'
hk' : c'.Rel (e.f j) k'
a : ι
ha : e.f a = k'
⊢ c'.Rel (e.f j) (e.f a)
state_after: no goals
tactic: simpa only [ha] using hk'
Theorem: ENNReal.toNNReal_inv
File: Mathlib/Data/ENNReal/Real.lean

Proof steps:
state_before: a✝ b c d : ℝ≥0∞
r p q : ℝ≥0
a : ℝ≥0∞
⊢ a⁻¹.toNNReal = a.toNNReal⁻¹
state_after: case top
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ ⊤⁻¹.toNNReal = ⊤.toNNReal⁻¹

case coe
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ (↑a)⁻¹.toNNReal = (↑a).toNNReal⁻¹
tactic: induction' a with a
state_before: case coe
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
⊢ (↑a)⁻¹.toNNReal = (↑a).toNNReal⁻¹
state_after: case coe.inl
a b c d : ℝ≥0∞
r p q : ℝ≥0
⊢ (↑0)⁻¹.toNNReal = (↑0).toNNReal⁻¹

case coe.inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
ha : a ≠ 0
⊢ (↑a)⁻¹.toNNReal = (↑a).toNNReal⁻¹
tactic: rcases eq_or_ne a 0 with (rfl | ha)
state_before: case coe.inr
a✝ b c d : ℝ≥0∞
r p q a : ℝ≥0
ha : a ≠ 0
⊢ (↑a)⁻¹.toNNReal = (↑a).toNNReal⁻¹
state_after: no goals
tactic: rw [← coe_inv ha, toNNReal_coe, toNNReal_coe]
Theorem: Polynomial.natDegree_le_pred
File: Mathlib/Algebra/Polynomial/Degree/Definitions.lean

Proof steps:
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hf : p.natDegree ≤ n
hn : p.coeff n = 0
⊢ p.natDegree ≤ n - 1
state_after: case zero
R : Type u
S : Type v
a b c d : R
m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
hf : p.natDegree ≤ 0
hn : p.coeff 0 = 0
⊢ p.natDegree ≤ 0 - 1

case succ
R : Type u
S : Type v
a b c d : R
m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
n : ℕ
hf : p.natDegree ≤ n + 1
hn : p.coeff (n + 1) = 0
⊢ p.natDegree ≤ n + 1 - 1
tactic: obtain _ | n := n
Theorem: Complex.oangle
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Basic.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
w z : ℂ
⊢ Complex.orientation.oangle w z = ↑((starRingEnd ℂ) w * z).arg
state_after: no goals
tactic: simp [oangle]
Theorem: CategoryTheory.CosimplicialObject.equivalenceLeftToRight_right
File: Mathlib/AlgebraicTopology/CechNerve.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F.augmentedCechConerve ⟶ X
⊢ (𝟭 C).map G.left ≫ (Augmented.toArrow.obj X).hom =
    F.hom ≫ (𝟭 C).map (WidePushout.ι (fun x => F.hom) 0 ≫ G.right.app (SimplexCategory.mk 0))
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F.augmentedCechConerve ⟶ X
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) =
    F.hom ≫ WidePushout.ι (fun x => F.hom) 0 ≫ G.right.app (SimplexCategory.mk 0)
tactic: dsimp
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F.augmentedCechConerve ⟶ X
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) =
    F.hom ≫ WidePushout.ι (fun x => F.hom) 0 ≫ G.right.app (SimplexCategory.mk 0)
state_after: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F.augmentedCechConerve ⟶ X
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) = (WidePushout.head fun x => F.hom) ≫ G.right.app (SimplexCategory.mk 0)
tactic: rw [@WidePushout.arrow_ι_assoc _ _ _ _ _ (fun (_ : Fin 1) => F.hom)
      (by dsimp; infer_instance)]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
inst✝ : ∀ (n : ℕ) (f : Arrow C), HasWidePushout f.left (fun x => f.right) fun x => f.hom
F : Arrow C
X : Augmented C
G : F.augmentedCechConerve ⟶ X
⊢ G.left ≫ X.hom.app (SimplexCategory.mk 0) = (WidePushout.head fun x => F.hom) ≫ G.right.app (SimplexCategory.mk 0)
state_after: no goals
tactic: exact congr_app G.w (SimplexCategory.mk 0)
Theorem: MeasureTheory.lintegral_eq_zero_iff'
File: Mathlib/MeasureTheory/Integral/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
f : α → ℝ≥0∞
hf : AEMeasurable f μ
⊢ ∫⁻ (x : α), 0 ∂μ ≠ ⊤
state_after: no goals
tactic: simp [lintegral_zero, zero_ne_top]
Theorem: IsTensorProduct.map_eq
File: Mathlib/RingTheory/IsTensorProduct.lean

Proof steps:
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
hf : IsTensorProduct f
hg : IsTensorProduct g
i₁ : M₁ →ₗ[R] N₁
i₂ : M₂ →ₗ[R] N₂
x₁ : M₁
x₂ : M₂
⊢ (hf.map hg i₁ i₂) ((f x₁) x₂) = (g (i₁ x₁)) (i₂ x₂)
state_after: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
hf : IsTensorProduct f
hg : IsTensorProduct g
i₁ : M₁ →ₗ[R] N₁
i₂ : M₂ →ₗ[R] N₂
x₁ : M₁
x₂ : M₂
⊢ (↑hg.equiv ∘ₗ TensorProduct.map i₁ i₂ ∘ₗ ↑hf.equiv.symm) ((f x₁) x₂) = (g (i₁ x₁)) (i₂ x₂)
tactic: delta IsTensorProduct.map
state_before: R : Type u_1
inst✝¹⁴ : CommSemiring R
M₁ : Type u_2
M₂ : Type u_3
M : Type u_4
M' : Type u_5
inst✝¹³ : AddCommMonoid M₁
inst✝¹² : AddCommMonoid M₂
inst✝¹¹ : AddCommMonoid M
inst✝¹⁰ : AddCommMonoid M'
inst✝⁹ : Module R M₁
inst✝⁸ : Module R M₂
inst✝⁷ : Module R M
inst✝⁶ : Module R M'
f : M₁ →ₗ[R] M₂ →ₗ[R] M
N₁ : Type u_6
N₂ : Type u_7
N : Type u_8
inst✝⁵ : AddCommMonoid N₁
inst✝⁴ : AddCommMonoid N₂
inst✝³ : AddCommMonoid N
inst✝² : Module R N₁
inst✝¹ : Module R N₂
inst✝ : Module R N
g : N₁ →ₗ[R] N₂ →ₗ[R] N
hf : IsTensorProduct f
hg : IsTensorProduct g
i₁ : M₁ →ₗ[R] N₁
i₂ : M₂ →ₗ[R] N₂
x₁ : M₁
x₂ : M₂
⊢ (↑hg.equiv ∘ₗ TensorProduct.map i₁ i₂ ∘ₗ ↑hf.equiv.symm) ((f x₁) x₂) = (g (i₁ x₁)) (i₂ x₂)
state_after: no goals
tactic: simp
Theorem: QuotientGroup.image_coe_inj
File: Mathlib/GroupTheory/QuotientGroup.lean

Proof steps:
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s t : Set G
⊢ mk '' s = mk '' t ↔ ↑N * s = ↑N * t
state_after: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s t : Set G
⊢ mk '' s = mk '' t ↔ mk ⁻¹' (mk '' s) = mk ⁻¹' (mk '' t)
tactic: simp_rw [← preimage_image_coe]
state_before: G : Type u
inst✝² : Group G
N : Subgroup G
nN : N.Normal
H : Type v
inst✝¹ : Group H
M : Type x
inst✝ : Monoid M
s t : Set G
⊢ mk '' s = mk '' t ↔ mk ⁻¹' (mk '' s) = mk ⁻¹' (mk '' t)
state_after: no goals
tactic: exact QuotientGroup.mk_surjective.preimage_injective.eq_iff.symm
Theorem: Matrix.natCast_fin_two
File: Mathlib/Data/Matrix/Notation.lean

Proof steps:
state_before: α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
⊢ ↑n = !![↑n, 0; 0, ↑n]
state_after: case a
α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
i j : Fin 2
⊢ ↑n i j = !![↑n, 0; 0, ↑n] i j
tactic: ext i j
state_before: case a
α : Type u
o n✝ m : ℕ
m' : Type uₘ
n' : Type uₙ
o' : Type uₒ
a b : ℕ
inst✝ : AddMonoidWithOne α
n : ℕ
i j : Fin 2
⊢ ↑n i j = !![↑n, 0; 0, ↑n] i j
state_after: no goals
tactic: fin_cases i <;> fin_cases j <;> rfl
Theorem: CochainComplex.mappingCone.liftCocycle_coe
File: Mathlib/Algebra/Homology/HomotopyCategory/MappingCone.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
inst✝⁴ : Category.{?u.197151, u_1} C
inst✝³ : Category.{?u.197155, u_2} D
inst✝² : Preadditive C
inst✝¹ : Preadditive D
F G : CochainComplex C ℤ
φ : F ⟶ G
inst✝ : HasHomotopyCofiber φ
K : CochainComplex C ℤ
n m : ℤ
α : Cocycle K F m
β : Cochain K G n
h : n + 1 = m
eq : δ n m β + (↑α).comp (Cochain.ofHom φ) ⋯ = 0
⊢ δ n m (liftCochain φ (↑α) β h) = 0
state_after: no goals
tactic: simp only [δ_liftCochain φ α β h (m+1) rfl, eq,
      Cocycle.δ_eq_zero, Cochain.zero_comp, neg_zero, add_zero]
Theorem: CategoryTheory.SimplicialObject.Augmented.whiskering_map_app_right
File: Mathlib/AlgebraicTopology/SimplicialObject.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
⊢ (𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom =
    ((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))).app n
tactic: ext n
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ ((𝟭 (SimplicialObject D)).map (whiskerLeft (drop.obj A) η) ≫ ((whiskeringObj C D Y✝).obj A).hom).app n =
    (((whiskeringObj C D X✝).obj A).hom ≫ (const D).map (η.app (point.obj A))).app n
state_after: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ η.app (A.left.obj n) ≫ Y✝.map (A.hom.app n) ≫ 𝟙 (Y✝.obj A.right) =
    (X✝.map (A.hom.app n) ≫ 𝟙 (X✝.obj A.right)) ≫ η.app A.right
tactic: dsimp
state_before: case h
C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ : C ⥤ D
η : X✝ ⟶ Y✝
A : Augmented C
n : SimplexCategoryᵒᵖ
⊢ η.app (A.left.obj n) ≫ Y✝.map (A.hom.app n) ≫ 𝟙 (Y✝.obj A.right) =
    (X✝.map (A.hom.app n) ≫ 𝟙 (X✝.obj A.right)) ≫ η.app A.right
state_after: no goals
tactic: rw [Category.comp_id, Category.comp_id, η.naturality]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X : SimplicialObject C
D : Type u'
inst✝ : Category.{v', u'} D
X✝ Y✝ Z✝ : C ⥤ D
x✝¹ : X✝ ⟶ Y✝
x✝ : Y✝ ⟶ Z✝
⊢ { obj := whiskeringObj C D,
          map := fun {X Y} η =>
            { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
              naturality := ⋯ } }.map
      (x✝¹ ≫ x✝) =
    { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
                naturality := ⋯ } }.map
        x✝¹ ≫
      { obj := whiskeringObj C D,
            map := fun {X Y} η =>
              { app := fun A => { left := whiskerLeft (drop.obj A) η, right := η.app (point.obj A), w := ⋯ },
                naturality := ⋯ } }.map
        x✝
state_after: no goals
tactic: ext <;> rfl
Theorem: Orientation.rotation_eq_self_iff
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Rotation.lean

Proof steps:
state_before: V : Type u_1
V' : Type u_2
inst✝⁵ : NormedAddCommGroup V
inst✝⁴ : NormedAddCommGroup V'
inst✝³ : InnerProductSpace ℝ V
inst✝² : InnerProductSpace ℝ V'
inst✝¹ : Fact (finrank ℝ V = 2)
inst✝ : Fact (finrank ℝ V' = 2)
o : Orientation ℝ V (Fin 2)
x : V
θ : Real.Angle
⊢ (o.rotation θ) x = x ↔ x = 0 ∨ θ = 0
state_after: no goals
tactic: by_cases h : x = 0 <;> simp [h]
Theorem: Function.mulSupport_prod_mk'
File: Mathlib/Algebra/Group/Support.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
A : Type u_3
B : Type u_4
M : Type u_5
M' : Type u_6
N : Type u_7
P : Type u_8
G : Type u_9
inst✝² : One M
inst✝¹ : One N
inst✝ : One P
f : α → M × N
⊢ mulSupport f = (mulSupport fun x => (f x).1) ∪ mulSupport fun x => (f x).2
state_after: no goals
tactic: simp only [← mulSupport_prod_mk]
Theorem: AlgebraicGeometry.Spec.toLocallyRingedSpace_obj
File: Mathlib/AlgebraicGeometry/Spec.lean

Proof steps:
state_before: R : CommRingCatᵒᵖ
⊢ { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map (𝟙 R) =
    𝟙 ({ obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.obj R)
state_after: R : CommRingCatᵒᵖ
⊢ locallyRingedSpaceMap (𝟙 (unop R)) = 𝟙 (locallyRingedSpaceObj (unop R))
tactic: dsimp
state_before: R : CommRingCatᵒᵖ
⊢ locallyRingedSpaceMap (𝟙 (unop R)) = 𝟙 (locallyRingedSpaceObj (unop R))
state_after: no goals
tactic: rw [Spec.locallyRingedSpaceMap_id]
state_before: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map (f ≫ g) =
    { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map f ≫
      { obj := fun R => locallyRingedSpaceObj (unop R), map := fun {X Y} f => locallyRingedSpaceMap f.unop }.map g
state_after: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ locallyRingedSpaceMap (g.unop ≫ f.unop) = locallyRingedSpaceMap f.unop ≫ locallyRingedSpaceMap g.unop
tactic: dsimp
state_before: X✝ Y✝ Z✝ : CommRingCatᵒᵖ
f : X✝ ⟶ Y✝
g : Y✝ ⟶ Z✝
⊢ locallyRingedSpaceMap (g.unop ≫ f.unop) = locallyRingedSpaceMap f.unop ≫ locallyRingedSpaceMap g.unop
state_after: no goals
tactic: rw [Spec.locallyRingedSpaceMap_comp]
Theorem: quadraticChar_exists_neg_one'
File: Mathlib/NumberTheory/LegendreSymbol/QuadraticChar/Basic.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
⊢ ∃ a, (quadraticChar F) ↑a = -1
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
x✝ : ∃ a, (quadraticChar F) a = -1
a : F
ha : (quadraticChar F) a = -1
⊢ IsUnit a
tactic: refine (fun ⟨a, ha⟩ ↦ ⟨IsUnit.unit ?_, ha⟩) (quadraticChar_exists_neg_one hF)
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
x✝ : ∃ a, (quadraticChar F) a = -1
a : F
ha : (quadraticChar F) a = -1
⊢ IsUnit a
state_after: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
x✝ : ∃ a, (quadraticChar F) a = -1
a : F
ha : ¬IsUnit a
⊢ ¬(quadraticChar F) a = -1
tactic: contrapose ha
state_before: F : Type u_1
inst✝² : Field F
inst✝¹ : Fintype F
inst✝ : DecidableEq F
hF : ringChar F ≠ 2
x✝ : ∃ a, (quadraticChar F) a = -1
a : F
ha : ¬IsUnit a
⊢ ¬(quadraticChar F) a = -1
state_after: no goals
tactic: exact ne_of_eq_of_ne ((quadraticChar F).map_nonunit ha) (mt zero_eq_neg.mp one_ne_zero)
Theorem: Fin.map_valEmbedding_Ioo
File: Mathlib/Order/Interval/Finset/Fin.lean

Proof steps:
state_before: n : ℕ
a b : Fin n
⊢ map valEmbedding (Ioo a b) = Ioo ↑a ↑b
state_after: no goals
tactic: simp [Ioo_eq_finset_subtype, Finset.fin, Finset.map_map]
Theorem: Finset.weightedVSubOfPoint_vadd
File: Mathlib/LinearAlgebra/AffineSpace/Combination.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝² : Ring k
inst✝¹ : AddCommGroup V
inst✝ : Module k V
S : AffineSpace V P
ι : Type u_4
s✝ : Finset ι
ι₂ : Type u_5
s₂ : Finset ι₂
s : Finset ι
w : ι → k
p : ι → P
b : P
v : V
⊢ (s.weightedVSubOfPoint (v +ᵥ p) b) w = (s.weightedVSubOfPoint p (-v +ᵥ b)) w
state_after: no goals
tactic: simp [vadd_vsub_assoc, vsub_vadd_eq_vsub_sub, add_comm]
Theorem: Homotopy.symm_hom
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✝ : ι
f g : C ⟶ D
h : Homotopy f g
i j : ι
w : ¬c.Rel j i
⊢ (-h.hom) i j = 0
state_after: no goals
tactic: rw [Pi.neg_apply, Pi.neg_apply, h.zero i j w, neg_zero]
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✝ : ι
f g : C ⟶ D
h : Homotopy f g
i : ι
⊢ g.f i = (dNext i) (-h.hom) + (prevD i) (-h.hom) + f.f i
state_after: no goals
tactic: rw [AddMonoidHom.map_neg, AddMonoidHom.map_neg, h.comm, ← neg_add, ← add_assoc, neg_add_self,
      zero_add]
Theorem: padicValNat_mul_pow_right
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (p ^ n * q ^ m) = m
state_after: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (q ^ m * p ^ n) = m
tactic: rw [mul_comm (p^n) (q^m)]
state_before: p q : ℕ
hp : Fact (Nat.Prime p)
hq : Fact (Nat.Prime q)
n m : ℕ
neq : q ≠ p
⊢ padicValNat q (q ^ m * p ^ n) = m
state_after: no goals
tactic: exact padicValNat_mul_pow_left m n neq
Theorem: ContinuousMultilinearMap.norm_compContinuousLinearMap_le
File: Mathlib/Analysis/NormedSpace/Multilinear/Basic.lean

Proof steps:
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
g : ContinuousMultilinearMap 𝕜 E₁ G
f : (i : ι) → E i →L[𝕜] E₁ i
⊢ 0 ≤ ‖g‖ * ∏ i : ι, ‖f i‖
state_after: no goals
tactic: positivity
state_before: 𝕜 : Type u
ι : Type v
ι' : Type v'
E : ι → Type wE
E₁ : ι → Type wE₁
E' : ι' → Type wE'
G : Type wG
G' : Type wG'
inst✝¹² : Fintype ι
inst✝¹¹ : Fintype ι'
inst✝¹⁰ : NontriviallyNormedField 𝕜
inst✝⁹ : (i : ι) → SeminormedAddCommGroup (E i)
inst✝⁸ : (i : ι) → NormedSpace 𝕜 (E i)
inst✝⁷ : (i : ι) → SeminormedAddCommGroup (E₁ i)
inst✝⁶ : (i : ι) → NormedSpace 𝕜 (E₁ i)
inst✝⁵ : (i : ι') → SeminormedAddCommGroup (E' i)
inst✝⁴ : (i : ι') → NormedSpace 𝕜 (E' i)
inst✝³ : SeminormedAddCommGroup G
inst✝² : NormedSpace 𝕜 G
inst✝¹ : SeminormedAddCommGroup G'
inst✝ : NormedSpace 𝕜 G'
g : ContinuousMultilinearMap 𝕜 E₁ G
f : (i : ι) → E i →L[𝕜] E₁ i
m : (i : ι) → E i
⊢ ‖g‖ * ∏ i : ι, ‖f i‖ * ‖m i‖ = (‖g‖ * ∏ i : ι, ‖f i‖) * ∏ i : ι, ‖m i‖
state_after: no goals
tactic: rw [prod_mul_distrib, mul_assoc]
Theorem: CochainComplex.shiftFunctorAdd'_eq
File: Mathlib/Algebra/Homology/HomotopyCategory/Shift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b c : ℤ
h : a + b = c
⊢ CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h = shiftFunctorAdd' C a b c h
state_after: case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b c : ℤ
h : a + b = c
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h).hom.app x✝).f i✝ =
    ((shiftFunctorAdd' C a b c h).hom.app x✝).f i✝
tactic: ext
state_before: case w.w.h.h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
D : Type u'
inst✝¹ : Category.{v', u'} D
inst✝ : Preadditive D
a b c : ℤ
h : a + b = c
x✝ : CochainComplex C ℤ
i✝ : ℤ
⊢ ((CategoryTheory.shiftFunctorAdd' (CochainComplex C ℤ) a b c h).hom.app x✝).f i✝ =
    ((shiftFunctorAdd' C a b c h).hom.app x✝).f i✝
state_after: no goals
tactic: simp only [shiftFunctorAdd'_hom_app_f', XIsoOfEq, eqToIso.hom, shiftFunctorAdd'_hom_app_f]