ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Computation.liftRel_pure_left
File: Mathlib/Data/Seq/Computation.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ pure a
⊢ ∃ b, b ∈ cb ∧ R a' b
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ pure a
⊢ ∃ b, b ∈ cb ∧ R a b
tactic: rw [eq_of_pure_mem ma']
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
a' : α
ma' : a' ∈ pure a
⊢ ∃ b, b ∈ cb ∧ R a b
state_after: no goals
tactic: exact ⟨b, mb, ab⟩
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ R a b'
state_after: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ R a b
tactic: rw [mem_unique mb' mb]
state_before: α : Type u
β : Type v
γ : Type w
R : α → β → Prop
a : α
cb : Computation β
x✝ : ∃ b, b ∈ cb ∧ R a b
b : β
mb : b ∈ cb
ab : R a b
b' : β
mb' : b' ∈ cb
⊢ R a b
state_after: no goals
tactic: exact ab
Theorem: CategoryTheory.Pretriangulated.productTriangle.π_hom₁
File: Mathlib/CategoryTheory/Triangulated/Basic.lean

Proof steps:
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (productTriangle T).mor₃ ≫ (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: dsimp
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ ((Pi.map fun j => (T j).mor₃) ≫ inv (piComparison (shiftFunctor C 1) fun j => (T j).obj₁)) ≫
      (shiftFunctor C 1).map (Pi.π (fun j => (T j).obj₁) j) =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
tactic: rw [← piComparison_comp_π, assoc, IsIso.inv_hom_id_assoc]
state_before: C : Type u
inst✝⁵ : Category.{v, u} C
inst✝⁴ : HasShift C ℤ
T₁ T₂ T₃ : Triangle C
J : Type u_1
T : J → Triangle C
inst✝³ : HasProduct fun j => (T j).obj₁
inst✝² : HasProduct fun j => (T j).obj₂
inst✝¹ : HasProduct fun j => (T j).obj₃
inst✝ : HasProduct fun j => (shiftFunctor C 1).obj (T j).obj₁
j : J
⊢ (Pi.map fun j => (T j).mor₃) ≫ Pi.π (fun b => (shiftFunctor C 1).obj (T b).obj₁) j =
    Pi.π (fun j => (T j).obj₃) j ≫ (T j).mor₃
state_after: no goals
tactic: simp only [limMap_π, Discrete.natTrans_app]
Theorem: EReal.exp_add
File: Mathlib/Analysis/SpecialFunctions/Log/ERealExp.lean

Proof steps:
state_before: x y : EReal
⊢ (x + y).exp = x.exp * y.exp
state_after: case h_bot
y : EReal
⊢ (⊥ + y).exp = ⊥.exp * y.exp

case h_real
y : EReal
a✝ : ℝ
⊢ (↑a✝ + y).exp = (↑a✝).exp * y.exp

case h_top
y : EReal
⊢ (⊤ + y).exp = ⊤.exp * y.exp
tactic: induction x
Theorem: NonUnitalAlgHom.ext_iff
File: Mathlib/Algebra/Algebra/NonUnitalHom.lean

Proof steps:
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f g : A →ₛₙₐ[φ] B
⊢ f = g → ∀ (x : A), f x = g x
state_after: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f : A →ₛₙₐ[φ] B
x : A
⊢ f x = f x
tactic: rintro rfl x
state_before: R : Type u
S : Type u₁
T : Type u_1
inst✝⁸ : Monoid R
inst✝⁷ : Monoid S
inst✝⁶ : Monoid T
φ : R →* S
A : Type v
B : Type w
C : Type w₁
inst✝⁵ : NonUnitalNonAssocSemiring A
inst✝⁴ : DistribMulAction R A
inst✝³ : NonUnitalNonAssocSemiring B
inst✝² : DistribMulAction S B
inst✝¹ : NonUnitalNonAssocSemiring C
inst✝ : DistribMulAction T C
f : A →ₛₙₐ[φ] B
x : A
⊢ f x = f x
state_after: no goals
tactic: rfl
Theorem: Complex.norm_natCast_cpow_of_re_ne_zero
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: n : ℕ
s : ℂ
hs : s.re ≠ 0
⊢ ‖↑n ^ s‖ = ↑n ^ s.re
state_after: no goals
tactic: rw [norm_eq_abs, ← ofReal_natCast, abs_cpow_eq_rpow_re_of_nonneg n.cast_nonneg hs]
Theorem: IsLocalMin.inv
File: Mathlib/Topology/Algebra/Field.lean

Proof steps:
state_before: K : Type u_1
inst✝³ : DivisionRing K
inst✝² : TopologicalSpace K
α : Type u_2
β : Type u_3
inst✝¹ : TopologicalSpace α
inst✝ : LinearOrderedSemifield β
a✝ : α
f : α → β
a : α
h1 : IsLocalMin f a
h2 : ∀ᶠ (z : α) in 𝓝 a, 0 < f z
⊢ IsLocalMax f⁻¹ a
state_after: no goals
tactic: filter_upwards [h1, h2] with z h3 h4 using(inv_le_inv h4 h2.self_of_nhds).mpr h3
Theorem: continuous_extendFrom
File: Mathlib/Topology/ExtendFrom.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : RegularSpace Y
f : X → Y
A : Set X
hA : Dense A
hf : ∀ (x : X), ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)
⊢ Continuous (extendFrom A f)
state_after: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : RegularSpace Y
f : X → Y
A : Set X
hA : Dense A
hf : ∀ (x : X), ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)
⊢ ContinuousOn (extendFrom A f) univ
tactic: rw [continuous_iff_continuousOn_univ]
state_before: X : Type u_1
Y : Type u_2
inst✝² : TopologicalSpace X
inst✝¹ : TopologicalSpace Y
inst✝ : RegularSpace Y
f : X → Y
A : Set X
hA : Dense A
hf : ∀ (x : X), ∃ y, Tendsto f (𝓝[A] x) (𝓝 y)
⊢ ContinuousOn (extendFrom A f) univ
state_after: no goals
tactic: exact continuousOn_extendFrom (fun x _ ↦ hA x) (by simpa using hf)
Theorem: List.Perm.pmap
File: .lake/packages/batteries/Batteries/Data/List/Perm.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
p✝ : α → Prop
f : (a : α) → p✝ a → β
l₁ l₂ : List α
p : l₁ ~ l₂
H₁ : ∀ (a : α), a ∈ l₁ → p✝ a
H₂ : ∀ (a : α), a ∈ l₂ → p✝ a
⊢ List.pmap f l₁ H₁ ~ List.pmap f l₂ H₂
state_after: no goals
tactic: induction p with
  | nil => simp
  | cons x _p IH => simp [IH, Perm.cons]
  | swap x y => simp [swap]
  | trans _p₁ p₂ IH₁ IH₂ => exact IH₁.trans (IH₂ (H₁ := fun a m => H₂ a (p₂.subset m)))
Theorem: Set.le_ncard_diff
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
⊢ t.ncard ≤ s.ncard + (t \ s).ncard
state_after: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
⊢ t.ncard ≤ (t \ s).ncard + s.ncard
tactic: rw [add_comm]
state_before: α : Type u_1
β : Type u_2
s✝ t✝ : Set α
f : α → β
s t : Set α
hs : autoParam s.Finite _auto✝
⊢ t.ncard ≤ (t \ s).ncard + s.ncard
state_after: no goals
tactic: apply ncard_le_ncard_diff_add_ncard _ _ hs
Theorem: EuclideanGeometry.oangle_add_oangle_add_oangle_eq_pi
File: Mathlib/Geometry/Euclidean/Triangle.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
inst✝¹ : Module.Oriented ℝ V (Fin 2)
inst✝ : Fact (FiniteDimensional.finrank ℝ V = 2)
p1 p2 p3 : P
h21 : p2 ≠ p1
h32 : p3 ≠ p2
h13 : p1 ≠ p3
⊢ ∡ p1 p2 p3 + ∡ p2 p3 p1 + ∡ p3 p1 p2 = ↑π
state_after: no goals
tactic: simpa only [neg_vsub_eq_vsub_rev] using
    positiveOrientation.oangle_add_cyc3_neg_left (vsub_ne_zero.mpr h21) (vsub_ne_zero.mpr h32)
      (vsub_ne_zero.mpr h13)
Theorem: AddMonoid.mem_closure_union_iff
File: Mathlib/Deprecated/Submonoid.lean

Proof steps:
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t✝ : Set A
M : Type u_3
inst✝ : CommMonoid M
s t : Set M
x : M
hx : x ∈ Closure (s ∪ t)
L : List M
HL1✝ : ∀ x ∈ L, x ∈ s ∪ t
HL2 : L.prod = x
hd : M
tl : List M
ih : (∀ x ∈ tl, x ∈ s ∪ t) → ∃ y ∈ Closure s, ∃ z ∈ Closure t, y * z = tl.prod
HL1 : ∀ x ∈ hd :: tl, x ∈ s ∪ t
y : M
hy : y ∈ Closure s
z : M
hz : z ∈ Closure t
hyzx : y * z = tl.prod
hs : hd ∈ s
⊢ hd * y * z = (hd :: tl).prod
state_after: no goals
tactic: rw [mul_assoc, List.prod_cons, ← hyzx]
state_before: M✝ : Type u_1
inst✝² : Monoid M✝
s✝ : Set M✝
A : Type u_2
inst✝¹ : AddMonoid A
t✝ : Set A
M : Type u_3
inst✝ : CommMonoid M
s t : Set M
x : M
hx : x ∈ Closure (s ∪ t)
L : List M
HL1✝ : ∀ x ∈ L, x ∈ s ∪ t
HL2 : L.prod = x
hd : M
tl : List M
ih : (∀ x ∈ tl, x ∈ s ∪ t) → ∃ y ∈ Closure s, ∃ z ∈ Closure t, y * z = tl.prod
HL1 : ∀ x ∈ hd :: tl, x ∈ s ∪ t
y : M
hy : y ∈ Closure s
z : M
hz : z ∈ Closure t
hyzx : y * z = tl.prod
ht : hd ∈ t
⊢ y * (z * hd) = (hd :: tl).prod
state_after: no goals
tactic: rw [← mul_assoc, List.prod_cons, ← hyzx, mul_comm hd]
Theorem: CategoryTheory.Pseudofunctor.whiskerRight_mapId_hom
File: Mathlib/CategoryTheory/Bicategory/Functor/Pseudofunctor.lean

Proof steps:
state_before: B : Type u₁
inst✝² : Bicategory B
C : Type u₂
inst✝¹ : Bicategory C
D : Type u₃
inst✝ : Bicategory D
F✝ F : Pseudofunctor B C
a b : B
f : a ⟶ b
⊢ (F.mapId a).hom ▷ F.map f = (F.mapComp (𝟙 a) f).inv ≫ F.map₂ (λ_ f).hom ≫ (λ_ (F.map f)).inv
state_after: no goals
tactic: simp [whiskerRightIso_mapId]
Theorem: List.modifyNth_succ_cons
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: α : Type u_1
f : α → α
a : α
l : List α
n : Nat
⊢ modifyNth f (n + 1) (a :: l) = a :: modifyNth f n l
state_after: no goals
tactic: rfl
Theorem: CstarRing.star_mul_self_ne_zero_iff
File: Mathlib/Analysis/CstarAlgebra/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
α : Type u_3
inst✝² : NonUnitalNormedRing E
inst✝¹ : StarRing E
inst✝ : CstarRing E
x : E
⊢ x⋆ * x ≠ 0 ↔ x ≠ 0
state_after: no goals
tactic: simp only [Ne, star_mul_self_eq_zero_iff]
Theorem: Turing.PartrecToTM2.K'.elim_update_main
File: Mathlib/Computability/TMToPartrec.lean

Proof steps:
state_before: a b c d a' : List Γ'
⊢ update (elim a b c d) main a' = elim a' b c d
state_after: case h
a b c d a' : List Γ'
x : K'
⊢ update (elim a b c d) main a' x = elim a' b c d x
tactic: funext x
state_before: case h
a b c d a' : List Γ'
x : K'
⊢ update (elim a b c d) main a' x = elim a' b c d x
state_after: no goals
tactic: cases x <;> rfl
Theorem: MeasureTheory.Integrable.ae_eq_of_withDensityᵥ_eq
File: Mathlib/MeasureTheory/Measure/WithDensityVectorMeasure.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
⊢ f =ᶠ[ae μ] g
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
i : Set α
hi : MeasurableSet i
x✝ : μ i < ⊤
⊢ ∫ (x : α) in i, f x ∂μ = ∫ (x : α) in i, g x ∂μ
tactic: refine hf.ae_eq_of_forall_setIntegral_eq f g hg fun i hi _ => ?_
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ ν : Measure α
E : Type u_3
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : CompleteSpace E
f✝ g✝ f g : α → E
hf : Integrable f μ
hg : Integrable g μ
hfg : μ.withDensityᵥ f = μ.withDensityᵥ g
i : Set α
hi : MeasurableSet i
x✝ : μ i < ⊤
⊢ ∫ (x : α) in i, f x ∂μ = ∫ (x : α) in i, g x ∂μ
state_after: no goals
tactic: rw [← withDensityᵥ_apply hf hi, hfg, withDensityᵥ_apply hg hi]
Theorem: midpoint_neg_self
File: Mathlib/LinearAlgebra/AffineSpace/Midpoint.lean

Proof steps:
state_before: R : Type u_1
V : Type u_2
V' : Type u_3
P : Type u_4
P' : Type u_5
inst✝⁷ : Ring R
inst✝⁶ : Invertible 2
inst✝⁵ : AddCommGroup V
inst✝⁴ : Module R V
inst✝³ : AddTorsor V P
inst✝² : AddCommGroup V'
inst✝¹ : Module R V'
inst✝ : AddTorsor V' P'
x✝ y z : P
x : V
⊢ midpoint R (-x) x = 0
state_after: no goals
tactic: simpa using midpoint_self_neg R (-x)
Theorem: AffineSubspace.mem_perpBisector_pointReflection_iff_inner_eq_zero
File: Mathlib/Geometry/Euclidean/PerpBisector.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
c c₁ c₂ p₁ p₂ : P
⊢ c ∈ perpBisector p₁ ((Equiv.pointReflection p₂) p₁) ↔ ⟪c -ᵥ p₂, p₁ -ᵥ p₂⟫_ℝ = 0
state_after: no goals
tactic: rw [mem_perpBisector_iff_inner_eq_zero, midpoint_pointReflection_right,
    Equiv.pointReflection_apply, vadd_vsub_assoc, inner_add_right, add_self_eq_zero,
    ← neg_eq_zero, ← inner_neg_right, neg_vsub_eq_vsub_rev]
Theorem: mulRothNumber_map_mul_left
File: Mathlib/Combinatorics/Additive/AP/Three/Defs.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ mulRothNumber (map (mulLeftEmbedding a) s) = mulRothNumber s
state_after: case refine_1
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ mulRothNumber (map (mulLeftEmbedding a) s) ≤ mulRothNumber s

case refine_2
F : Type u_1
α : Type u_2
β : Type u_3
𝕜 : Type u_4
E : Type u_5
inst✝¹ : DecidableEq α
inst✝ : CancelCommMonoid α
s : Finset α
a : α
⊢ mulRothNumber s ≤ mulRothNumber (map (mulLeftEmbedding a) s)
tactic: refine le_antisymm ?_ ?_
Theorem: finrank_le_one_iff
File: Mathlib/LinearAlgebra/Dimension/FreeAndStrongRankCondition.lean

Proof steps:
state_before: K : Type u
V : Type v
inst✝⁵ : Ring K
inst✝⁴ : StrongRankCondition K
inst✝³ : AddCommGroup V
inst✝² : Module K V
inst✝¹ : Module.Free K V
inst✝ : Module.Finite K V
⊢ finrank K V ≤ 1 ↔ ∃ v, ∀ (w : V), ∃ c, c • v = w
state_after: no goals
tactic: rw [← rank_le_one_iff, ← finrank_eq_rank, ← natCast_le, Nat.cast_one]
Theorem: Algebra.adjoin_restrictScalars
File: Mathlib/RingTheory/Adjoin/Tower.lean

Proof steps:
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
⊢ Subalgebra.restrictScalars C (adjoin D S) =
    Subalgebra.restrictScalars C (adjoin (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) S)
state_after: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
⊢ Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E)
tactic: suffices
    Set.range (algebraMap D E) =
      Set.range (algebraMap ((⊤ : Subalgebra C D).map (IsScalarTower.toAlgHom C D E)) E) by
    ext x
    change x ∈ Subsemiring.closure (_ ∪ S) ↔ x ∈ Subsemiring.closure (_ ∪ S)
    rw [this]
state_before: R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
⊢ Set.range ⇑(algebraMap D E) = Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E)
state_after: case h
R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
x : E
⊢ x ∈ Set.range ⇑(algebraMap D E) ↔ x ∈ Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E)
tactic: ext x
state_before: case h
R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
x : E
⊢ x ∈ Set.range ⇑(algebraMap D E) ↔ x ∈ Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E)
state_after: case h.mp
R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
x : E
⊢ x ∈ Set.range ⇑(algebraMap D E) → x ∈ Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E)

case h.mpr
R : Type u
S✝ : Type v
A : Type w
B : Type u₁
C : Type u_1
D : Type u_2
E : Type u_3
inst✝⁶ : CommSemiring C
inst✝⁵ : CommSemiring D
inst✝⁴ : CommSemiring E
inst✝³ : Algebra C D
inst✝² : Algebra C E
inst✝¹ : Algebra D E
inst✝ : IsScalarTower C D E
S : Set E
x : E
⊢ x ∈ Set.range ⇑(algebraMap (↥(Subalgebra.map (IsScalarTower.toAlgHom C D E) ⊤)) E) → x ∈ Set.range ⇑(algebraMap D E)
tactic: constructor
Theorem: MeasurableEmbedding.lintegral_map
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 α
inst✝ : MeasurableSpace β
g : α → β
hg : MeasurableEmbedding g
f : β → ℝ≥0∞
⊢ ∫⁻ (a : β), f a ∂Measure.map g μ = ∫⁻ (a : α), f (g a) ∂μ
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace β
g : α → β
hg : MeasurableEmbedding g
f : β → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a), g_1.lintegral (Measure.map g μ) =
    ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f (g a)), g_1.lintegral μ
tactic: rw [lintegral, lintegral]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace β
g : α → β
hg : MeasurableEmbedding g
f : β → ℝ≥0∞
⊢ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a), g_1.lintegral (Measure.map g μ) =
    ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f (g a)), g_1.lintegral μ
state_after: case refine_1
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace β
g : α → β
hg : MeasurableEmbedding g
f : β → ℝ≥0∞
f₀ : β →ₛ ℝ≥0∞
hf₀ : ↑f₀ ≤ fun a => f a
⊢ f₀.lintegral (Measure.map g μ) ≤ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f (g a)), g_1.lintegral μ

case refine_2
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
m : MeasurableSpace α
μ ν : Measure α
inst✝ : MeasurableSpace β
g : α → β
hg : MeasurableEmbedding g
f : β → ℝ≥0∞
f₀ : α →ₛ ℝ≥0∞
hf₀ : ↑f₀ ≤ fun a => f (g a)
⊢ f₀.lintegral μ ≤ ⨆ g_1, ⨆ (_ : ↑g_1 ≤ fun a => f a), g_1.lintegral (Measure.map g μ)
tactic: refine le_antisymm (iSup₂_le fun f₀ hf₀ => ?_) (iSup₂_le fun f₀ hf₀ => ?_)
Theorem: Matroid.ground_not_base
File: Mathlib/Data/Matroid/Dual.lean

Proof steps:
state_before: α : Type u_1
M✝ : Matroid α
I B X : Set α
M : Matroid α
h : M✶.RkPos
⊢ ¬M.Base M.E
state_after: no goals
tactic: rwa [rkPos_iff_empty_not_base, dual_base_iff, diff_empty] at h
Theorem: LinearMap.trace_id
File: Mathlib/LinearAlgebra/Trace.lean

Proof steps:
state_before: R : Type u_1
inst✝¹² : CommRing R
M : Type u_2
inst✝¹¹ : AddCommGroup M
inst✝¹⁰ : Module R M
N : Type u_3
P : Type u_4
inst✝⁹ : AddCommGroup N
inst✝⁸ : Module R N
inst✝⁷ : AddCommGroup P
inst✝⁶ : Module R P
ι : Type u_5
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : Module.Free R N
inst✝² : Module.Finite R N
inst✝¹ : Module.Free R P
inst✝ : Module.Finite R P
⊢ (trace R M) id = ↑(finrank R M)
state_after: no goals
tactic: rw [← one_eq_id, trace_one]
Theorem: Cycle.formPerm_reverse
File: Mathlib/GroupTheory/Perm/Cycle/Concrete.lean

Proof steps:
state_before: α : Type u_1
inst✝ : DecidableEq α
s✝ s' s : Cycle α
h : s.Nodup
⊢ s.reverse.formPerm ⋯ = (s.formPerm h)⁻¹
state_after: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
⊢ (reverse (Quot.mk Setoid.r a✝)).formPerm ⋯ = (formPerm (Quot.mk Setoid.r a✝) h)⁻¹
tactic: induction s using Quot.inductionOn
state_before: case h
α : Type u_1
inst✝ : DecidableEq α
s s' : Cycle α
a✝ : List α
h : Nodup (Quot.mk Setoid.r a✝)
⊢ (reverse (Quot.mk Setoid.r a✝)).formPerm ⋯ = (formPerm (Quot.mk Setoid.r a✝) h)⁻¹
state_after: no goals
tactic: simpa using formPerm_reverse _
Theorem: Fin.update_cons_zero
File: Mathlib/Data/Fin/Tuple/Basic.lean

Proof steps:
state_before: m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
⊢ update (cons x p) 0 z = cons z p
state_after: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin (n + 1)
⊢ update (cons x p) 0 z j = cons z p j
tactic: ext j
state_before: case h
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin (n + 1)
⊢ update (cons x p) 0 z j = cons z p j
state_after: case pos
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin (n + 1)
h : j = 0
⊢ update (cons x p) 0 z j = cons z p j

case neg
m n : ℕ
α : Fin (n + 1) → Type u
x : α 0
q : (i : Fin (n + 1)) → α i
p : (i : Fin n) → α i.succ
i : Fin n
y : α i.succ
z : α 0
j : Fin (n + 1)
h : ¬j = 0
⊢ update (cons x p) 0 z j = cons z p j
tactic: by_cases h : j = 0
Theorem: Odd.mul
File: Mathlib/Algebra/Ring/Parity.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
a b : α
m n : ℕ
⊢ Odd a → Odd b → Odd (a * b)
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ Odd ((2 * a + 1) * (2 * b + 1))
tactic: rintro ⟨a, rfl⟩ ⟨b, rfl⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ Odd ((2 * a + 1) * (2 * b + 1))
state_after: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ (2 * a + 1) * (2 * b + 1) = 2 * (2 * a * b + b + a) + 1
tactic: refine ⟨2 * a * b + b + a, ?_⟩
state_before: case intro.intro
F : Type u_1
α : Type u_2
β : Type u_3
R : Type u_4
inst✝¹ : Semiring α
inst✝ : Semiring β
m n : ℕ
a b : α
⊢ (2 * a + 1) * (2 * b + 1) = 2 * (2 * a * b + b + a) + 1
state_after: no goals
tactic: rw [mul_add, add_mul, mul_one, ← add_assoc, one_mul, mul_assoc, ← mul_add, ← mul_add, ← mul_assoc,
    ← Nat.cast_two, ← Nat.cast_comm]