ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Orientation.tan_oangle_sub_left_mul_norm_of_oangle_eq_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/RightAngle.lean

Proof steps:
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : o.oangle x y = ↑(π / 2)
⊢ (o.oangle (x - y) x).tan * ‖x‖ = ‖y‖
state_after: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).tan * ‖x‖ = ‖y‖
tactic: rw [← neg_inj, oangle_rev, ← oangle_neg_orientation_eq_neg, neg_inj] at h ⊢
state_before: V : Type u_1
inst✝¹ : NormedAddCommGroup V
inst✝ : InnerProductSpace ℝ V
hd2 : Fact (finrank ℝ V = 2)
o : Orientation ℝ V (Fin 2)
x y : V
h : (-o).oangle y x = ↑(π / 2)
⊢ ((-o).oangle x (x - y)).tan * ‖x‖ = ‖y‖
state_after: no goals
tactic: exact (-o).tan_oangle_sub_right_mul_norm_of_oangle_eq_pi_div_two h
Theorem: DFA.evalFrom_append_singleton
File: Mathlib/Computability/DFA.lean

Proof steps:
state_before: α : Type u
σ : Type v
M : DFA α σ
s : σ
x : List α
a : α
⊢ M.evalFrom s (x ++ [a]) = M.step (M.evalFrom s x) a
state_after: no goals
tactic: simp only [evalFrom, List.foldl_append, List.foldl_cons, List.foldl_nil]
Theorem: Matrix.vec3_dotProduct'
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✝¹ : AddCommMonoid α
inst✝ : Mul α
a₀ a₁ a₂ b₀ b₁ b₂ : α
⊢ ![a₀, a₁, a₂] ⬝ᵥ ![b₀, b₁, b₂] = a₀ * b₀ + a₁ * b₁ + a₂ * b₂
state_after: no goals
tactic: rw [cons_dotProduct_cons, cons_dotProduct_cons, cons_dotProduct_cons, dotProduct_empty,
    add_zero, add_assoc]
Theorem: Polynomial.degree_add_eq_left_of_degree_lt
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
h : q.degree < p.degree
⊢ (p + q).coeff p.natDegree ≠ 0
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Semiring R
p✝ p q : R[X]
ι : Type u_1
h : q.degree < p.degree
⊢ p.coeff p.natDegree ≠ 0
tactic: rw [coeff_add, coeff_natDegree_eq_zero_of_degree_lt h, add_zero]
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
h : q.degree < p.degree
⊢ p.coeff p.natDegree ≠ 0
state_after: no goals
tactic: exact mt leadingCoeff_eq_zero.1 (ne_zero_of_degree_gt h)
Theorem: SimplicialObject.Splitting.hom_ext
File: Mathlib/AlgebraicTopology/SplitSimplicialObject.lean

Proof steps:
state_before: C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
⊢ f = g
state_after: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
⊢ f.app Δ = g.app Δ
tactic: ext Δ
state_before: case h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
⊢ f.app Δ = g.app Δ
state_after: case h.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
⊢ ∀ (A : IndexSet Δ), (s.cofan Δ).inj A ≫ f.app Δ = (s.cofan Δ).inj A ≫ g.app Δ
tactic: apply s.hom_ext'
state_before: case h.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
⊢ ∀ (A : IndexSet Δ), (s.cofan Δ).inj A ≫ f.app Δ = (s.cofan Δ).inj A ≫ g.app Δ
state_after: case h.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (s.cofan Δ).inj A ≫ f.app Δ = (s.cofan Δ).inj A ≫ g.app Δ
tactic: intro A
state_before: case h.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategoryᵒᵖ
A : IndexSet Δ
⊢ (s.cofan Δ).inj A ≫ f.app Δ = (s.cofan Δ).inj A ≫ g.app Δ
state_after: case h.h.op
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategory
A : IndexSet (op Δ)
⊢ (s.cofan (op Δ)).inj A ≫ f.app (op Δ) = (s.cofan (op Δ)).inj A ≫ g.app (op Δ)
tactic: induction' Δ using Opposite.rec with Δ
state_before: case h.h.op
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
Δ : SimplexCategory
A : IndexSet (op Δ)
⊢ (s.cofan (op Δ)).inj A ≫ f.app (op Δ) = (s.cofan (op Δ)).inj A ≫ g.app (op Δ)
state_after: case h.h.op.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
n : ℕ
A : IndexSet (op [n])
⊢ (s.cofan (op [n])).inj A ≫ f.app (op [n]) = (s.cofan (op [n])).inj A ≫ g.app (op [n])
tactic: induction' Δ using SimplexCategory.rec with n
state_before: case h.h.op.h
C : Type u_1
inst✝ : Category.{u_2, u_1} C
X Y : SimplicialObject C
s : Splitting X
f g : X ⟶ Y
h : ∀ (n : ℕ), s.φ f n = s.φ g n
n : ℕ
A : IndexSet (op [n])
⊢ (s.cofan (op [n])).inj A ≫ f.app (op [n]) = (s.cofan (op [n])).inj A ≫ g.app (op [n])
state_after: no goals
tactic: simp only [s.cofan_inj_comp_app, h]
Theorem: ascPochhammer_map
File: Mathlib/RingTheory/Polynomial/Pochhammer.lean

Proof steps:
state_before: S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
n : ℕ
⊢ map f (ascPochhammer S n) = ascPochhammer T n
state_after: case zero
S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
⊢ map f (ascPochhammer S 0) = ascPochhammer T 0

case succ
S : Type u
inst✝¹ : Semiring S
T : Type v
inst✝ : Semiring T
f : S →+* T
n : ℕ
ih : map f (ascPochhammer S n) = ascPochhammer T n
⊢ map f (ascPochhammer S (n + 1)) = ascPochhammer T (n + 1)
tactic: induction' n with n ih
Theorem: MvPolynomial.IsHomogeneous.inj_right
File: Mathlib/RingTheory/MvPolynomial/Homogeneous.lean

Proof steps:
state_before: σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n : ℕ
hm : φ.IsHomogeneous m
hn : φ.IsHomogeneous n
hφ : φ ≠ 0
⊢ m = n
state_after: case intro
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n : ℕ
hm : φ.IsHomogeneous m
hn : φ.IsHomogeneous n
hφ : φ ≠ 0
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
tactic: obtain ⟨d, hd⟩ : ∃ d, coeff d φ ≠ 0 := exists_coeff_ne_zero hφ
state_before: case intro
σ : Type u_1
τ : Type u_2
R : Type u_3
S : Type u_4
inst✝² inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
φ ψ : MvPolynomial σ R
m n : ℕ
hm : φ.IsHomogeneous m
hn : φ.IsHomogeneous n
hφ : φ ≠ 0
d : σ →₀ ℕ
hd : coeff d φ ≠ 0
⊢ m = n
state_after: no goals
tactic: rw [← hm hd, ← hn hd]
Theorem: Stream'.WSeq.flatten_equiv
File: Mathlib/Data/Seq/WSeq.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ flatten c ~ʷ s
state_after: case h1
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ flatten (Computation.pure s) ~ʷ s

case h2
α : Type u
β : Type v
γ : Type w
c : Computation (WSeq α)
s : WSeq α
h : s ∈ c
⊢ ∀ (s_1 : Computation (WSeq α)), flatten s_1 ~ʷ s → flatten s_1.think ~ʷ s
tactic: apply Computation.memRecOn h
Theorem: Matrix.nondegenerate_iff_det_ne_zero
File: Mathlib/LinearAlgebra/Matrix/ToLinearEquiv.lean

Proof steps:
state_before: n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate ↔ M.det ≠ 0
state_after: n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate ↔ ¬∃ v, v ≠ 0 ∧ v ᵥ* M = 0
tactic: rw [ne_eq, ← exists_vecMul_eq_zero_iff]
state_before: n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate ↔ ¬∃ v, v ≠ 0 ∧ v ᵥ* M = 0
state_after: n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate ↔ ∀ (v : n → A), v ≠ 0 → v ᵥ* M ≠ 0
tactic: push_neg
state_before: n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate ↔ ∀ (v : n → A), v ≠ 0 → v ᵥ* M ≠ 0
state_after: case mp
n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ M.Nondegenerate → ∀ (v : n → A), v ≠ 0 → v ᵥ* M ≠ 0

case mpr
n : Type u_1
inst✝⁶ : Fintype n
R : Type u_2
M✝ : Type u_3
inst✝⁵ : CommRing R
inst✝⁴ : AddCommGroup M✝
inst✝³ : Module R M✝
A : Type u_4
inst✝² : DecidableEq n
inst✝¹ : CommRing A
inst✝ : IsDomain A
M : Matrix n n A
⊢ (∀ (v : n → A), v ≠ 0 → v ᵥ* M ≠ 0) → M.Nondegenerate
tactic: constructor
Theorem: AbsoluteValue.map_units_intCast
File: Mathlib/Data/Int/AbsoluteValue.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
inst✝² : Ring R
inst✝¹ : LinearOrderedCommRing S
inst✝ : Nontrivial R
abv : AbsoluteValue R S
x : ℤˣ
⊢ abv ↑↑x = 1
state_after: no goals
tactic: rcases Int.units_eq_one_or x with (rfl | rfl) <;> simp
Theorem: CategoryTheory.Functor.opUnopEquiv_counitIso
File: Mathlib/CategoryTheory/Opposites.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
⊢ ∀ {X Y : (C ⥤ D)ᵒᵖ} (f : X ⟶ Y),
    (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) Y).hom =
      ((fun F => (unop F).opUnopIso.op) X).hom ≫ (opHom C D ⋙ opInv C D).map f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) G).hom =
    ((fun F => (unop F).opUnopIso.op) F).hom ≫ (opHom C D ⋙ opInv C D).map f
tactic: intro F G f
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (𝟭 (C ⥤ D)ᵒᵖ).map f ≫ ((fun F => (unop F).opUnopIso.op) G).hom =
    ((fun F => (unop F).opUnopIso.op) F).hom ≫ (opHom C D ⋙ opInv C D).map f
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ f ≫ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom.op =
    (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom.op ≫
      Quiver.Hom.op { app := fun X => f.unop.app X, naturality := ⋯ }
tactic: dsimp [opUnopIso]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ f ≫ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom.op =
    (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom.op ≫
      Quiver.Hom.op { app := fun X => f.unop.app X, naturality := ⋯ }
state_after: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ ((NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop).op =
    ({ app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
        (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom).op
tactic: rw [show f = f.unop.op by simp, ← op_comp, ← op_comp]
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ ((NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop).op =
    ({ app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
        (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom).op
state_after: case e_f
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop =
    { app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
      (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom
tactic: congr 1
state_before: case e_f
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
F G : (C ⥤ D)ᵒᵖ
f : F ⟶ G
⊢ (NatIso.ofComponents (fun X => Iso.refl ((unop G).obj X)) ⋯).hom ≫ f.unop =
    { app := fun X => f.unop.op.unop.app X, naturality := ⋯ } ≫
      (NatIso.ofComponents (fun X => Iso.refl ((unop F).obj X)) ⋯).hom
state_after: no goals
tactic: aesop_cat
Theorem: interior_sInter_subset
File: Mathlib/Topology/Basic.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Sort w
α : Type u_1
β : Type u_2
x : X
s s₁ s₂ t : Set X
p p₁ p₂ : X → Prop
inst✝ : TopologicalSpace X
S : Set (Set X)
⊢ interior (⋂₀ S) = interior (⋂ s ∈ S, s)
state_after: no goals
tactic: rw [sInter_eq_biInter]
Theorem: add_lt_iff_neg_left
File: Mathlib/Algebra/Order/Monoid/Unbundled/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : MulOneClass α
inst✝² : LT α
inst✝¹ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
inst✝ : ContravariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x < x_1
a b : α
⊢ a * b < a ↔ a * b < a * 1
state_after: no goals
tactic: rw [mul_one]
Theorem: Antivary.card_smul_sum_le_sum_smul_sum
File: Mathlib/Algebra/Order/Chebyshev.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
inst✝⁴ : LinearOrderedRing α
inst✝³ : LinearOrderedAddCommGroup β
inst✝² : Module α β
inst✝¹ : OrderedSMul α β
s : Finset ι
σ : Perm ι
f : ι → α
g : ι → β
inst✝ : Fintype ι
hfg : Antivary f g
⊢ Fintype.card ι • ∑ i : ι, f i • g i ≤ (∑ i : ι, f i) • ∑ i : ι, g i
state_after: no goals
tactic: exact (hfg.dual_right.monovaryOn _).sum_smul_sum_le_card_smul_sum
Theorem: CategoryTheory.isCoseparator_prod_of_isCoseparator_left
File: Mathlib/CategoryTheory/Generator.lean

Proof steps:
state_before: C : Type u₁
inst✝³ : Category.{v₁, u₁} C
D : Type u₂
inst✝² : Category.{v₂, u₂} D
inst✝¹ : HasZeroMorphisms C
G H : C
inst✝ : HasBinaryProduct G H
hG : IsCoseparator G
⊢ {G} ⊆ {G, H}
state_after: no goals
tactic: simp
Theorem: MeasureTheory.setToFun_add_left'
File: Mathlib/MeasureTheory/Integral/SetToL1.lean

Proof steps:
state_before: α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T'' s = T s + T' s
f : α → E
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f
state_after: case pos
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T'' s = T s + T' s
f : α → E
hf : Integrable f μ
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f

case neg
α : Type u_1
E : Type u_2
F : Type u_3
F' : Type u_4
G : Type u_5
𝕜 : Type u_6
p : ℝ≥0∞
inst✝⁷ : NormedAddCommGroup E
inst✝⁶ : NormedSpace ℝ E
inst✝⁵ : NormedAddCommGroup F
inst✝⁴ : NormedSpace ℝ F
inst✝³ : NormedAddCommGroup F'
inst✝² : NormedSpace ℝ F'
inst✝¹ : NormedAddCommGroup G
m : MeasurableSpace α
μ : Measure α
inst✝ : CompleteSpace F
T T' T'' : Set α → E →L[ℝ] F
C C' C'' : ℝ
f✝ g : α → E
hT : DominatedFinMeasAdditive μ T C
hT' : DominatedFinMeasAdditive μ T' C'
hT'' : DominatedFinMeasAdditive μ T'' C''
h_add : ∀ (s : Set α), MeasurableSet s → μ s < ⊤ → T'' s = T s + T' s
f : α → E
hf : ¬Integrable f μ
⊢ setToFun μ T'' hT'' f = setToFun μ T hT f + setToFun μ T' hT' f
tactic: by_cases hf : Integrable f μ
Theorem: CochainComplex.HomComplex.Cochain.leftShift_add
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplexShift.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
⊢ (γ₁ + γ₂).leftShift a n' hn' = γ₁.leftShift a n' hn' + γ₂.leftShift a n' hn'
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).leftShift a n' hn').v p q hpq = (γ₁.leftShift a n' hn' + γ₂.leftShift a n' hn').v p q hpq
tactic: ext p q hpq
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).leftShift a n' hn').v p q hpq = (γ₁.leftShift a n' hn' + γ₂.leftShift a n' hn').v p q hpq
state_after: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).leftShift a n' hn').v p q hpq = (γ₁.leftShift a n' hn').v p q hpq + (γ₂.leftShift a n' hn').v p q hpq
tactic: dsimp
state_before: case h
C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
K L M : CochainComplex C ℤ
n : ℤ
γ γ₁ γ₂ : Cochain K L n
a n' : ℤ
hn' : n + a = n'
p q : ℤ
hpq : p + n' = q
⊢ ((γ₁ + γ₂).leftShift a n' hn').v p q hpq = (γ₁.leftShift a n' hn').v p q hpq + (γ₂.leftShift a n' hn').v p q hpq
state_after: no goals
tactic: simp only [leftShift_v _ a n' hn' p q hpq (p + a) (by omega), add_v, comp_add, smul_add]
Theorem: Affine.Triangle.circumsphere_eq_circumsphere_of_eq_of_eq_of_two_zsmul_oangle_eq
File: Mathlib/Geometry/Euclidean/Angle/Sphere.lean

Proof steps:
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
t₁ t₂ : Triangle ℝ P
i₁ i₂ i₃ : Fin 3
h₁₂ : i₁ ≠ i₂
h₁₃ : i₁ ≠ i₃
h₂₃ : i₂ ≠ i₃
h₁ : t₁.points i₁ = t₂.points i₁
h₃ : t₁.points i₃ = t₂.points i₃
h₂ : 2 • ∡ (t₁.points i₁) (t₁.points i₂) (t₁.points i₃) = 2 • ∡ (t₂.points i₁) (t₂.points i₂) (t₂.points i₃)
⊢ Simplex.circumsphere t₁ = Simplex.circumsphere t₂
state_after: no goals
tactic: rw [t₁.circumsphere_eq_of_dist_of_oangle h₁₂ h₁₃ h₂₃,
    t₂.circumsphere_eq_of_dist_of_oangle h₁₂ h₁₃ h₂₃,
    -- Porting note: was `congrm ⟨((_ : ℝ)⁻¹ / 2) • _ +ᵥ _, _ / _ / 2⟩` and five more lines
    Real.Angle.tan_eq_of_two_zsmul_eq h₂, Real.Angle.abs_sin_eq_of_two_zsmul_eq h₂, h₁, h₃]
Theorem: CentroidHom.cancel_left
File: Mathlib/Algebra/Ring/CentroidHom.lean

Proof steps:
state_before: F : Type u_1
M : Type u_2
N : Type u_3
R : Type u_4
α : Type u_5
inst✝ : NonUnitalNonAssocSemiring α
g f₁ f₂ : CentroidHom α
hg : Injective ⇑g
h : g.comp f₁ = g.comp f₂
a : α
⊢ g (f₁ a) = g (f₂ a)
state_after: no goals
tactic: rw [← comp_apply, h, comp_apply]
Theorem: CategoryTheory.Prod.braiding_unitIso_hom_app
File: Mathlib/CategoryTheory/Products/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : C × D
⊢ (𝟭 (C × D)).obj X = (swap C D ⋙ swap D C).obj X
state_after: no goals
tactic: simp
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
X : D × C
⊢ (swap D C ⋙ swap C D).obj X = (𝟭 (D × C)).obj X
state_after: no goals
tactic: simp
Theorem: Equiv.Perm.exists_fixed_point_of_prime
File: Mathlib/GroupTheory/Perm/Cycle/Type.lean

Proof steps:
state_before: α : Type u_1
inst✝ : Fintype α
p n : ℕ
hp : Fact (Nat.Prime p)
hα : ¬p ∣ Fintype.card α
σ : Perm α
hσ : σ ^ p ^ n = 1
⊢ ∃ a, σ a = a
state_after: no goals
tactic: classical
    contrapose! hα
    simp_rw [← mem_support, ← Finset.eq_univ_iff_forall] at hα
    exact Nat.modEq_zero_iff_dvd.1 ((congr_arg _ (Finset.card_eq_zero.2 (compl_eq_bot.2 hα))).mp
      (card_compl_support_modEq hσ).symm)
Theorem: eVariationOn.mono
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s t : Set α
hst : t ⊆ s
⊢ eVariationOn f t ≤ eVariationOn f s
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s t : Set α
hst : t ⊆ s
⊢ ∀ (i : ℕ × { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ t }),
    ∑ i_1 ∈ Finset.range i.1, edist (f (↑i.2 (i_1 + 1))) (f (↑i.2 i_1)) ≤ eVariationOn f s
tactic: apply iSup_le _
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s t : Set α
hst : t ⊆ s
⊢ ∀ (i : ℕ × { u // Monotone u ∧ ∀ (i : ℕ), u i ∈ t }),
    ∑ i_1 ∈ Finset.range i.1, edist (f (↑i.2 (i_1 + 1))) (f (↑i.2 i_1)) ≤ eVariationOn f s
state_after: case mk.mk.intro
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s t : Set α
hst : t ⊆ s
n : ℕ
u : ℕ → α
hu : Monotone u
ut : ∀ (i : ℕ), u i ∈ t
⊢ ∑ i ∈ Finset.range (n, ⟨u, ⋯⟩).1, edist (f (↑(n, ⟨u, ⋯⟩).2 (i + 1))) (f (↑(n, ⟨u, ⋯⟩).2 i)) ≤ eVariationOn f s
tactic: rintro ⟨n, ⟨u, hu, ut⟩⟩
state_before: case mk.mk.intro
α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s t : Set α
hst : t ⊆ s
n : ℕ
u : ℕ → α
hu : Monotone u
ut : ∀ (i : ℕ), u i ∈ t
⊢ ∑ i ∈ Finset.range (n, ⟨u, ⋯⟩).1, edist (f (↑(n, ⟨u, ⋯⟩).2 (i + 1))) (f (↑(n, ⟨u, ⋯⟩).2 i)) ≤ eVariationOn f s
state_after: no goals
tactic: exact sum_le f n hu fun i => hst (ut i)
Theorem: ContinuousMultilinearMap.isLeast_opNNNorm
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'
c : 𝕜
f g : ContinuousMultilinearMap 𝕜 E G
m : (i : ι) → E i
𝕜' : Type u_1
inst✝² : NormedField 𝕜'
inst✝¹ : NormedSpace 𝕜' G
inst✝ : SMulCommClass 𝕜 𝕜' G
⊢ IsLeast {C | ∀ (m : (i : ι) → E i), ‖f m‖₊ ≤ C * ∏ i : ι, ‖m i‖₊} ‖f‖₊
state_after: no goals
tactic: simpa only [← opNNNorm_le_iff] using isLeast_Ici
Theorem: Option.bind_eq_some'
File: Mathlib/Data/Option/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
x : Option α
f : α → Option β
b : β
⊢ x.bind f = some b ↔ ∃ a, x = some a ∧ f a = some b
state_after: no goals
tactic: cases x <;> simp