ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: SetTheory.PGame.add_left_neg_le_zero
File: Mathlib/SetTheory/Game/PGame.lean

Proof steps:
state_before: xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : (-mk xl xr xL xR + mk xl xr xL xR).LeftMoves
⊢ ∃ j, ((-mk xl xr xL xR + mk xl xr xL xR).moveLeft i).moveRight j ≤ 0
state_after: case inl
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xr
⊢ ∃ j, ((-mk xl xr xL xR + mk xl xr xL xR).moveLeft (Sum.inl i)).moveRight j ≤ 0

case inr
xl✝ xr✝ : Type u
xl xr : Type u_1
xL : xl → PGame
xR : xr → PGame
i : xl
⊢ ∃ j, ((-mk xl xr xL xR + mk xl xr xL xR).moveLeft (Sum.inr i)).moveRight j ≤ 0
tactic: cases' i with i i
Theorem: HurwitzZeta.completedCosZeta_one_sub
File: Mathlib/NumberTheory/LSeries/HurwitzZetaEven.lean

Proof steps:
state_before: a : UnitAddCircle
s : ℂ
⊢ completedCosZeta a (1 - s) = completedHurwitzZetaEven a s
state_after: no goals
tactic: rw [← completedHurwitzZetaEven_one_sub, sub_sub_cancel]
Theorem: intervalIntegrable_iff_integrableOn_Ioc_of_le
File: Mathlib/MeasureTheory/Integral/IntervalIntegral.lean

Proof steps:
state_before: ι : Type u_1
𝕜 : Type u_2
E : Type u_3
F : Type u_4
A : Type u_5
inst✝ : NormedAddCommGroup E
f : ℝ → E
a b : ℝ
μ : Measure ℝ
hab : a ≤ b
⊢ IntervalIntegrable f μ a b ↔ IntegrableOn f (Ioc a b) μ
state_after: no goals
tactic: rw [intervalIntegrable_iff, uIoc_of_le hab]
Theorem: Ideal.one_eq_top
File: Mathlib/RingTheory/Ideal/Operations.lean

Proof steps:
state_before: R : Type u
ι : Type u_1
inst✝ : CommSemiring R
I J K L : Ideal R
⊢ 1 = ⊤
state_after: no goals
tactic: erw [Submodule.one_eq_range, LinearMap.range_id]
Theorem: Complex.imCLM_norm
File: Mathlib/Analysis/Complex/OperatorNorm.lean

Proof steps:
state_before: ⊢ 1 = ‖imCLM I‖
state_after: no goals
tactic: simp
state_before: ⊢ ‖I‖ ≤ 1
state_after: no goals
tactic: simp
Theorem: Cardinal.aleph0_le_mul_iff'
File: Mathlib/SetTheory/Cardinal/Basic.lean

Proof steps:
state_before: α β : Type u
a b : Cardinal.{u}
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
tactic: have : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0 := fun a => ne_bot_of_le_ne_bot aleph0_ne_zero a
state_before: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ ℵ₀ ≤ a * b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ b ≠ 0 ∧ ℵ₀ ≤ a ∨ a ≠ 0 ∧ ℵ₀ ≤ b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
tactic: simp only [aleph0_le_mul_iff, and_or_left, and_iff_right_of_imp this, @and_left_comm (a ≠ 0)]
state_before: α β : Type u
a b : Cardinal.{u}
this : ∀ {a : Cardinal.{u}}, ℵ₀ ≤ a → a ≠ 0
⊢ b ≠ 0 ∧ ℵ₀ ≤ a ∨ a ≠ 0 ∧ ℵ₀ ≤ b ↔ a ≠ 0 ∧ ℵ₀ ≤ b ∨ ℵ₀ ≤ a ∧ b ≠ 0
state_after: no goals
tactic: simp only [and_comm, or_comm]
Theorem: IsAntichain.image_relEmbedding
File: Mathlib/Order/Antichain.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b : α
hs : IsAntichain r s
φ : r ↪r r'
⊢ IsAntichain r' (⇑φ '' s)
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : b ∈ ⇑φ '' s
b' : β
hb' : b' ∈ ⇑φ '' s
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
tactic: intro b hb b' hb' h₁ h₂
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : b ∈ ⇑φ '' s
b' : β
hb' : b' ∈ ⇑φ '' s
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
state_after: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : ∃ x ∈ s, φ x = b
b' : β
hb' : ∃ x ∈ s, φ x = b'
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
tactic: rw [Set.mem_image] at hb hb'
state_before: α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a b✝ : α
hs : IsAntichain r s
φ : r ↪r r'
b : β
hb : ∃ x ∈ s, φ x = b
b' : β
hb' : ∃ x ∈ s, φ x = b'
h₁ : b ≠ b'
h₂ : r' b b'
⊢ False
state_after: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b : α
hs : IsAntichain r s
φ : r ↪r r'
a : α
has : a ∈ s
a' : α
has' : a' ∈ s
h₁ : φ a ≠ φ a'
h₂ : r' (φ a) (φ a')
⊢ False
tactic: obtain ⟨⟨a, has, rfl⟩, ⟨a', has', rfl⟩⟩ := hb, hb'
state_before: case intro.intro.intro.intro
α : Type u_1
β : Type u_2
r r₁ r₂ : α → α → Prop
r' : β → β → Prop
s t : Set α
a✝ b : α
hs : IsAntichain r s
φ : r ↪r r'
a : α
has : a ∈ s
a' : α
has' : a' ∈ s
h₁ : φ a ≠ φ a'
h₂ : r' (φ a) (φ a')
⊢ False
state_after: no goals
tactic: exact hs has has' (fun haa' => h₁ (by rw [haa'])) (φ.map_rel_iff.mp h₂)
Theorem: MeasureTheory.measure_sUnion_null_iff
File: Mathlib/MeasureTheory/OuterMeasure/Basic.lean

Proof steps:
state_before: α : Type u_1
ι : Type u_2
F : Type u_3
inst✝¹ : FunLike F (Set α) ℝ≥0∞
inst✝ : OuterMeasureClass F α
μ : F
s t : Set α
S : Set (Set α)
hS : S.Countable
⊢ μ (⋃₀ S) = 0 ↔ ∀ s ∈ S, μ s = 0
state_after: no goals
tactic: rw [sUnion_eq_biUnion, measure_biUnion_null_iff hS]
Theorem: Nat.Prime.primeFactorsList_pow
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ (p ^ n).primeFactorsList = replicate n p
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p = (p ^ n).primeFactorsList
tactic: symm
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p = (p ^ n).primeFactorsList
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p ~ (p ^ n).primeFactorsList
tactic: rw [← List.replicate_perm]
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ replicate n p ~ (p ^ n).primeFactorsList
state_after: p : ℕ
hp : Prime p
n : ℕ
⊢ ∀ p_1 ∈ replicate n p, Prime p_1
tactic: apply Nat.primeFactorsList_unique (List.prod_replicate n p)
state_before: p : ℕ
hp : Prime p
n : ℕ
⊢ ∀ p_1 ∈ replicate n p, Prime p_1
state_after: p : ℕ
hp : Prime p
n q : ℕ
hq : q ∈ replicate n p
⊢ Prime q
tactic: intro q hq
state_before: p : ℕ
hp : Prime p
n q : ℕ
hq : q ∈ replicate n p
⊢ Prime q
state_after: no goals
tactic: rwa [eq_of_mem_replicate hq]
Theorem: MeasureTheory.OuterMeasure.trim_binop
File: Mathlib/MeasureTheory/OuterMeasure/Induced.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), m₁ s = op (m₂ s) (m₃ s)
s : Set α
⊢ m₁.trim s = op (m₂.trim s) (m₃.trim s)
state_after: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), m₁ s = op (m₂ s) (m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm : ∀ (i : Fin (Nat.succ 0).succ.succ), (![m₁, m₂, m₃] i) t = (![m₁, m₂, m₃] i).trim s
⊢ m₁.trim s = op (m₂.trim s) (m₃.trim s)
tactic: rcases exists_measurable_superset_forall_eq_trim ![m₁, m₂, m₃] s with ⟨t, _hst, _ht, htm⟩
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), m₁ s = op (m₂ s) (m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm : ∀ (i : Fin (Nat.succ 0).succ.succ), (![m₁, m₂, m₃] i) t = (![m₁, m₂, m₃] i).trim s
⊢ m₁.trim s = op (m₂.trim s) (m₃.trim s)
state_after: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), m₁ s = op (m₂ s) (m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm : m₁ t = m₁.trim s ∧ m₂ t = m₂.trim s ∧ m₃ t = m₃.trim s ∧ ∀ (i : Fin 0), (![] i) t = (![] i).trim s
⊢ m₁.trim s = op (m₂.trim s) (m₃.trim s)
tactic: simp only [Fin.forall_fin_succ, Matrix.cons_val_zero, Matrix.cons_val_succ] at htm
state_before: case intro.intro.intro
α : Type u_1
inst✝ : MeasurableSpace α
m m₁ m₂ m₃ : OuterMeasure α
op : ℝ≥0∞ → ℝ≥0∞ → ℝ≥0∞
h : ∀ (s : Set α), m₁ s = op (m₂ s) (m₃ s)
s t : Set α
_hst : s ⊆ t
_ht : MeasurableSet t
htm : m₁ t = m₁.trim s ∧ m₂ t = m₂.trim s ∧ m₃ t = m₃.trim s ∧ ∀ (i : Fin 0), (![] i) t = (![] i).trim s
⊢ m₁.trim s = op (m₂.trim s) (m₃.trim s)
state_after: no goals
tactic: rw [← htm.1, ← htm.2.1, ← htm.2.2.1, h]
Theorem: FreeAddGroup.Red.Step.append_right
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ x✝¹ L₁✝ L₂✝ : List (α × Bool)
x✝ : α
b✝ : Bool
⊢ Step (L₁✝ ++ (x✝, b✝) :: (x✝, !b✝) :: L₂✝ ++ x✝¹) (L₁✝ ++ L₂✝ ++ x✝¹)
state_after: no goals
tactic: simp
Theorem: ProbabilityTheory.rnDeriv_gaussianReal
File: Mathlib/Probability/Distributions/Gaussian.lean

Proof steps:
state_before: μ : ℝ
v : ℝ≥0
⊢ ∂gaussianReal μ v/∂ℙ =ᶠ[ae ℙ] gaussianPDF μ v
state_after: case pos
μ : ℝ
v : ℝ≥0
hv : v = 0
⊢ ∂gaussianReal μ v/∂ℙ =ᶠ[ae ℙ] gaussianPDF μ v

case neg
μ : ℝ
v : ℝ≥0
hv : ¬v = 0
⊢ ∂gaussianReal μ v/∂ℙ =ᶠ[ae ℙ] gaussianPDF μ v
tactic: by_cases hv : v = 0
Theorem: intervalIntegral.continuous_parametric_intervalIntegral_of_continuous'
File: Mathlib/MeasureTheory/Integral/DominatedConvergence.lean

Proof steps:
state_before: E : Type u_1
X : Type u_2
inst✝⁴ : NormedAddCommGroup E
inst✝³ : NormedSpace ℝ E
inst✝² : TopologicalSpace X
a b b₀✝ b₁ b₂ : ℝ
μ : Measure ℝ
f✝ : ℝ → E
inst✝¹ : NoAtoms μ
inst✝ : IsLocallyFiniteMeasure μ
f : X → ℝ → E
hf : Continuous (Function.uncurry f)
a₀ b₀ : ℝ
⊢ Continuous fun x => ∫ (t : ℝ) in a₀..b₀, f x t ∂μ
state_after: no goals
tactic: fun_prop
Theorem: LinearMap.ker_le_of_iterateMapComap_eq_succ
File: Mathlib/Algebra/Module/Submodule/IterateMapComap.lean

Proof steps:
state_before: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
m : ℕ
heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K
hf : Surjective ⇑f
hi : Injective ⇑i
⊢ ker f ≤ K
state_after: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
m : ℕ
heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K
hf : Surjective ⇑f
hi : Injective ⇑i
⊢ ker f ≤ f.iterateMapComap i (0 + 1) K
tactic: rw [show K = _ from f.iterateMapComap_eq_succ i K m heq hf hi 0]
state_before: R : Type u_1
N : Type u_2
M : Type u_3
inst✝⁴ : Semiring R
inst✝³ : AddCommMonoid N
inst✝² : Module R N
inst✝¹ : AddCommMonoid M
inst✝ : Module R M
f i : N →ₗ[R] M
K : Submodule R N
m : ℕ
heq : f.iterateMapComap i m K = f.iterateMapComap i (m + 1) K
hf : Surjective ⇑f
hi : Injective ⇑i
⊢ ker f ≤ f.iterateMapComap i (0 + 1) K
state_after: no goals
tactic: exact f.ker_le_comap
Theorem: List.formPerm_eq_of_isRotated
File: Mathlib/GroupTheory/Perm/List.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l l' : List α
hd : l.Nodup
h : l ~r l'
⊢ l.formPerm = l'.formPerm
state_after: case intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hd : l.Nodup
n : ℕ
⊢ l.formPerm = (l.rotate n).formPerm
tactic: obtain ⟨n, rfl⟩ := h
state_before: case intro
α : Type u_1
β : Type u_2
inst✝ : DecidableEq α
l✝ : List α
x : α
l : List α
hd : l.Nodup
n : ℕ
⊢ l.formPerm = (l.rotate n).formPerm
state_after: no goals
tactic: exact (formPerm_rotate l hd n).symm
Theorem: AddCommute.right_comm
File: Mathlib/Algebra/Group/Commute/Defs.lean

Proof steps:
state_before: G : Type u_1
M : Type u_2
S : Type u_3
inst✝ : Semigroup S
a✝ b c : S
h : Commute b c
a : S
⊢ a * b * c = a * c * b
state_after: no goals
tactic: simp only [mul_assoc, h.eq]
Theorem: Multiset.toFinset_nonempty
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s t : Multiset α
⊢ s.toFinset.Nonempty ↔ s ≠ 0
state_after: no goals
tactic: simp only [toFinset_eq_empty, Ne, Finset.nonempty_iff_ne_empty]
Theorem: AlgebraicTopology.DoldKan.MorphComponents.postComp_φ
File: Mathlib/AlgebraicTopology/DoldKan/Decomposition.lean

Proof steps:
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ (f.postComp h).φ = f.φ ≫ h
state_after: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ PInfty.f (n + 1) ≫ { a := f.a ≫ h, b := fun i => f.b i ≫ h }.a +
      ∑ i : Fin (n + 1), (P ↑i).f (n + 1) ≫ X.δ i.rev.succ ≫ { a := f.a ≫ h, b := fun i => f.b i ≫ h }.b i.rev =
    (PInfty.f (n + 1) ≫ f.a + ∑ i : Fin (n + 1), (P ↑i).f (n + 1) ≫ X.δ i.rev.succ ≫ f.b i.rev) ≫ h
tactic: unfold φ postComp
state_before: C : Type u_1
inst✝¹ : Category.{u_2, u_1} C
inst✝ : Preadditive C
X X' : SimplicialObject C
n : ℕ
Z Z' : C
f : MorphComponents X n Z
g : X' ⟶ X
h : Z ⟶ Z'
⊢ PInfty.f (n + 1) ≫ { a := f.a ≫ h, b := fun i => f.b i ≫ h }.a +
      ∑ i : Fin (n + 1), (P ↑i).f (n + 1) ≫ X.δ i.rev.succ ≫ { a := f.a ≫ h, b := fun i => f.b i ≫ h }.b i.rev =
    (PInfty.f (n + 1) ≫ f.a + ∑ i : Fin (n + 1), (P ↑i).f (n + 1) ≫ X.δ i.rev.succ ≫ f.b i.rev) ≫ h
state_after: no goals
tactic: simp only [add_comp, sum_comp, assoc]
Theorem: MeasureTheory.Measure.dirac_compProd_apply
File: Mathlib/Probability/Kernel/MeasureCompProd.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
mα : MeasurableSpace α
mβ : MeasurableSpace β
μ : Measure α
κ η : Kernel α β
inst✝¹ : MeasurableSingletonClass α
a : α
inst✝ : IsSFiniteKernel κ
s : Set (α × β)
hs : MeasurableSet s
⊢ (dirac a ⊗ₘ κ) s = (κ a) (Prod.mk a ⁻¹' s)
state_after: no goals
tactic: rw [compProd_apply hs, lintegral_dirac]
Theorem: TypeVec.append_prod_appendFun
File: Mathlib/Data/TypeVec.lean

Proof steps:
state_before: n✝ n : ℕ
α α' β β' : TypeVec.{u} n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁))
state_after: case a.h
n✝ n : ℕ
α α' β β' : TypeVec.{u} n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
i : Fin2 (n + 1)
a : ((α ⊗ β) ::: (φ × ψ)) i
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) i a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) i a
tactic: ext i a
state_before: case a.h
n✝ n : ℕ
α α' β β' : TypeVec.{u} n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
i : Fin2 (n + 1)
a : ((α ⊗ β) ::: (φ × ψ)) i
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) i a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) i a
state_after: case a.h.fz
n✝ n : ℕ
α α' β β' : TypeVec.{u} n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a : ((α ⊗ β) ::: (φ × ψ)) Fin2.fz
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) Fin2.fz a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) Fin2.fz a

case a.h.fs
n✝ n : ℕ
α α' β β' : TypeVec.{u} n
φ φ' ψ ψ' : Type u
f₀ : α ⟹ α'
g₀ : β ⟹ β'
f₁ : φ → φ'
g₁ : ψ → ψ'
a✝ : Fin2 n
a : ((α ⊗ β) ::: (φ × ψ)) a✝.fs
⊢ (f₀ ⊗' g₀ ::: Prod.map f₁ g₁) a✝.fs a = ((f₀ ::: f₁) ⊗' (g₀ ::: g₁)) a✝.fs a
tactic: cases i
Theorem: IntermediateField.adjoin_algebraic_toSubalgebra
File: Mathlib/FieldTheory/Adjoin.lean

Proof steps:
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsAlgebraic F x
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
tactic: simp only [isAlgebraic_iff_isIntegral] at hS
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
this : Algebra.IsIntegral F ↥(Algebra.adjoin F S)
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
tactic: have : Algebra.IsIntegral F (Algebra.adjoin F S) := by
    rwa [← le_integralClosure_iff_isIntegral, Algebra.adjoin_le_iff]
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
this : Algebra.IsIntegral F ↥(Algebra.adjoin F S)
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
state_after: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
this✝ : Algebra.IsIntegral F ↥(Algebra.adjoin F S)
this : IsField ↥(Algebra.adjoin F S)
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
tactic: have : IsField (Algebra.adjoin F S) := isField_of_isIntegral_of_isField' (Field.toIsField F)
state_before: F : Type u_1
inst✝² : Field F
E : Type u_2
inst✝¹ : Field E
inst✝ : Algebra F E
S✝ : Set E
α : E
S : Set E
hS : ∀ x ∈ S, IsIntegral F x
this✝ : Algebra.IsIntegral F ↥(Algebra.adjoin F S)
this : IsField ↥(Algebra.adjoin F S)
⊢ (adjoin F S).toSubalgebra = Algebra.adjoin F S
state_after: no goals
tactic: rw [← ((Algebra.adjoin F S).toIntermediateField' this).eq_adjoin_of_eq_algebra_adjoin F S] <;> rfl
Theorem: Finset.MulETransform.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : Group α
e : α
x : Finset α × Finset α
⊢ (mulETransformLeft e x).1.card + (mulETransformLeft e x).2.card +
      ((mulETransformRight e x).1.card + (mulETransformRight e x).2.card) =
    x.1.card + x.2.card + (x.1.card + x.2.card)
state_after: no goals
tactic: rw [add_add_add_comm, mulETransformLeft.card, mulETransformRight.card, ← mul_add, two_mul]
Theorem: Finset.inter_assoc
File: Mathlib/Data/Finset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
inst✝ : DecidableEq α
s s₁✝ s₂✝ t t₁ t₂ u v : Finset α
a b : α
s₁ s₂ s₃ : Finset α
x✝ : α
⊢ x✝ ∈ s₁ ∩ s₂ ∩ s₃ ↔ x✝ ∈ s₁ ∩ (s₂ ∩ s₃)
state_after: no goals
tactic: simp only [mem_inter, and_assoc]
Theorem: Polynomial.coeff_sub
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
p q : R[X]
n : ℕ
⊢ (p - q).coeff n = p.coeff n - q.coeff n
state_after: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } - q).coeff n = { toFinsupp := toFinsupp✝ }.coeff n - q.coeff n
tactic: rcases p with ⟨⟩
state_before: case ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
q : R[X]
n : ℕ
toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝ } - q).coeff n = { toFinsupp := toFinsupp✝ }.coeff n - q.coeff n
state_after: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝¹ } - { toFinsupp := toFinsupp✝ }).coeff n =
    { toFinsupp := toFinsupp✝¹ }.coeff n - { toFinsupp := toFinsupp✝ }.coeff n
tactic: rcases q with ⟨⟩
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ ({ toFinsupp := toFinsupp✝¹ } - { toFinsupp := toFinsupp✝ }).coeff n =
    { toFinsupp := toFinsupp✝¹ }.coeff n - { toFinsupp := toFinsupp✝ }.coeff n
state_after: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ - toFinsupp✝ } with
      | { toFinsupp := p } => ⇑p)
      n =
    (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ } with
        | { toFinsupp := p } => ⇑p)
        n -
      (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝ } with
        | { toFinsupp := p } => ⇑p)
        n
tactic: rw [← ofFinsupp_sub, coeff, coeff, coeff]
state_before: case ofFinsupp.ofFinsupp
R : Type u
a b : R
m n✝ : ℕ
inst✝ : Ring R
n : ℕ
toFinsupp✝¹ toFinsupp✝ : R[ℕ]
⊢ (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ - toFinsupp✝ } with
      | { toFinsupp := p } => ⇑p)
      n =
    (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝¹ } with
        | { toFinsupp := p } => ⇑p)
        n -
      (match (motive := R[X] → ℕ → R) { toFinsupp := toFinsupp✝ } with
        | { toFinsupp := p } => ⇑p)
        n
state_after: no goals
tactic: apply Finsupp.sub_apply
Theorem: Orientation.norm_div_tan_oangle_sub_right_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)
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖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 x y = ↑(π / 2)
hs : (o.oangle y (y - x)).sign = 1
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖y‖
tactic: have hs : (o.oangle y (y - x)).sign = 1 := by
    rw [oangle_sign_sub_right_swap, h, Real.Angle.sign_coe_pi_div_two]
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)
hs : (o.oangle y (y - x)).sign = 1
⊢ ‖x‖ / (o.oangle y (y - x)).tan = ‖y‖
state_after: no goals
tactic: rw [o.oangle_eq_angle_of_sign_eq_one hs, Real.Angle.tan_coe,
    InnerProductGeometry.norm_div_tan_angle_sub_of_inner_eq_zero
      (o.inner_rev_eq_zero_of_oangle_eq_pi_div_two h)
      (Or.inr (o.left_ne_zero_of_oangle_eq_pi_div_two h))]
Theorem: MeasureTheory.Measure.snd_zero
File: Mathlib/MeasureTheory/Constructions/Prod/Basic.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
E : Type u_6
inst✝⁶ : MeasurableSpace α
inst✝⁵ : MeasurableSpace α'
inst✝⁴ : MeasurableSpace β
inst✝³ : MeasurableSpace β'
inst✝² : MeasurableSpace γ
μ μ' : Measure α
ν ν' : Measure β
τ : Measure γ
inst✝¹ : NormedAddCommGroup E
inst✝ : SFinite ν
ρ : Measure (α × β)
⊢ snd 0 = 0
state_after: no goals
tactic: simp [snd]
Theorem: CategoryTheory.Equivalence.op_functor
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
e : C ≌ D
X : Cᵒᵖ
⊢ e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫ (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X) =
    𝟙 (e.functor.op.obj X)
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ (e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫
        (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X)).unop =
    (𝟙 (e.functor.op.obj X)).unop
tactic: apply Quiver.Hom.unop_inj
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ (e.functor.op.map ((NatIso.op e.unitIso).symm.hom.app X) ≫
        (NatIso.op e.counitIso).symm.hom.app (e.functor.op.obj X)).unop =
    (𝟙 (e.functor.op.obj X)).unop
state_after: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ e.counitIso.inv.app (e.functor.obj (unop X)) ≫ e.functor.map (e.unitIso.inv.app (unop X)) = 𝟙 (e.functor.obj (unop X))
tactic: dsimp
state_before: case a
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
e : C ≌ D
X : Cᵒᵖ
⊢ e.counitIso.inv.app (e.functor.obj (unop X)) ≫ e.functor.map (e.unitIso.inv.app (unop X)) = 𝟙 (e.functor.obj (unop X))
state_after: no goals
tactic: simp