ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: WeierstrassCurve.Affine.CoordinateRing.coe_norm_smul_basis
File: Mathlib/AlgebraicGeometry/EllipticCurve/Group.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ C ((Algebra.norm R[X]) (p • 1 + q • (mk W) Y)) - (C p + C q * Y) * (C p + C q * (-Y - C (C W.a₁ * X + C W.a₃))) =
    W.polynomial * C q ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ C (p ^ 2 - p * q * (C W.a₁ * X + C W.a₃) - q ^ 2 * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) -
      (C p + C q * Y) * (C p + C q * (-Y - C (C W.a₁ * X + C W.a₃))) =
    (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) * C q ^ 2
tactic: simp only [norm_smul_basis, polynomial]
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ C (p ^ 2 - p * q * (C W.a₁ * X + C W.a₃) - q ^ 2 * (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) -
      (C p + C q * Y) * (C p + C q * (-Y - C (C W.a₁ * X + C W.a₃))) =
    (Y ^ 2 + C (C W.a₁ * X + C W.a₃) * Y - C (X ^ 3 + C W.a₂ * X ^ 2 + C W.a₄ * X + C W.a₆)) * C q ^ 2
state_after: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ C p ^ 2 - C p * C q * (C (C W.a₁) * C X + C (C W.a₃)) -
        C q ^ 2 * (C X ^ 3 + C (C W.a₂) * C X ^ 2 + C (C W.a₄) * C X + C (C W.a₆)) -
      (C p + C q * Y) * (C p + C q * (-Y - (C (C W.a₁) * C X + C (C W.a₃)))) =
    (Y ^ 2 + (C (C W.a₁) * C X + C (C W.a₃)) * Y - (C X ^ 3 + C (C W.a₂) * C X ^ 2 + C (C W.a₄) * C X + C (C W.a₆))) *
      C q ^ 2
tactic: C_simp
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : Affine R
f : R →+* S
p q : R[X]
⊢ C p ^ 2 - C p * C q * (C (C W.a₁) * C X + C (C W.a₃)) -
        C q ^ 2 * (C X ^ 3 + C (C W.a₂) * C X ^ 2 + C (C W.a₄) * C X + C (C W.a₆)) -
      (C p + C q * Y) * (C p + C q * (-Y - (C (C W.a₁) * C X + C (C W.a₃)))) =
    (Y ^ 2 + (C (C W.a₁) * C X + C (C W.a₃)) * Y - (C X ^ 3 + C (C W.a₂) * C X ^ 2 + C (C W.a₄) * C X + C (C W.a₆))) *
      C q ^ 2
state_after: no goals
tactic: ring1
Theorem: AddChar.starComp_eq_inv
File: Mathlib/NumberTheory/LegendreSymbol/AddCharacter.lean

Proof steps:
state_before: R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
⊢ (↑(starRingEnd ℂ)).compAddChar φ = φ⁻¹
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ ((↑(starRingEnd ℂ)).compAddChar φ) a = φ⁻¹ a
tactic: ext1 a
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ ((↑(starRingEnd ℂ)).compAddChar φ) a = φ⁻¹ a
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
tactic: simp only [RingHom.toMonoidHom_eq_coe, MonoidHom.coe_compAddChar, MonoidHom.coe_coe,
    Function.comp_apply, inv_apply']
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
state_after: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
H : ‖↑⋯.unit‖ = 1
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
tactic: have H := Complex.norm_eq_one_of_mem_rootsOfUnity <| φ.val_mem_rootsOfUnity a hR
state_before: case h
R : Type u_1
inst✝ : CommRing R
hR : 0 < ringChar R
φ : AddChar R ℂ
a : R
H : ‖↑⋯.unit‖ = 1
⊢ (starRingEnd ℂ) (φ a) = (φ a)⁻¹
state_after: no goals
tactic: exact (Complex.inv_eq_conj H).symm
Theorem: GaloisInsertion.l_biInf_of_ul_eq_self
File: Mathlib/Order/GaloisConnection.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → α
hf : ∀ (i : ι) (hi : p i), u (l (f i hi)) = f i hi
⊢ l (⨅ i, ⨅ (hi : p i), f i hi) = ⨅ i, ⨅ (hi : p i), l (f i hi)
state_after: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → α
hf : ∀ (i : ι) (hi : p i), u (l (f i hi)) = f i hi
⊢ l (⨅ x, f ↑x ⋯) = ⨅ x, l (f ↑x ⋯)
tactic: rw [iInf_subtype', iInf_subtype']
state_before: α : Type u
β : Type v
γ : Type w
ι✝ : Sort x
κ : ι✝ → Sort u_1
a a₁ a₂ : α
b b₁ b₂ : β
l : α → β
u : β → α
inst✝¹ : CompleteLattice α
inst✝ : CompleteLattice β
gi : GaloisInsertion l u
ι : Sort x
p : ι → Prop
f : (i : ι) → p i → α
hf : ∀ (i : ι) (hi : p i), u (l (f i hi)) = f i hi
⊢ l (⨅ x, f ↑x ⋯) = ⨅ x, l (f ↑x ⋯)
state_after: no goals
tactic: exact gi.l_iInf_of_ul_eq_self _ fun _ => hf _ _
Theorem: Real.one_lt_rpow_of_pos_of_lt_one_of_neg
File: Mathlib/Analysis/SpecialFunctions/Pow/Real.lean

Proof steps:
state_before: x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 < x ^ z
state_after: case h.e'_3
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 = x ^ 0
tactic: convert rpow_lt_rpow_of_exponent_gt hx1 hx2 hz
state_before: case h.e'_3
x y z : ℝ
n : ℕ
hx1 : 0 < x
hx2 : x < 1
hz : z < 0
⊢ 1 = x ^ 0
state_after: no goals
tactic: exact (rpow_zero x).symm
Theorem: Subfield.closure_induction
File: Mathlib/Algebra/Field/Subfield.lean

Proof steps:
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
s : Set K
p : K → Prop
x : K
h : x ∈ closure s
mem : ∀ x ∈ s, p x
one : p 1
add : ∀ (x y : K), p x → p y → p (x + y)
neg : ∀ (x : K), p x → p (-x)
inv : ∀ (x : K), p x → p x⁻¹
mul : ∀ (x y : K), p x → p y → p (x * y)
⊢ p x
state_after: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
s : Set K
p : K → Prop
x : K
h : x ∈ closure s
mem : ∀ x ∈ s, p x
one : p 1
add : ∀ (x y : K), p x → p y → p (x + y)
neg : ∀ (x : K), p x → p (-x)
inv : ∀ (x : K), p x → p x⁻¹
mul : ∀ (x y : K), p x → p y → p (x * y)
this : Subfield K :=
  { carrier := p, mul_mem' := ⋯, one_mem' := one, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯, inv_mem' := inv }
⊢ p x
tactic: letI : Subfield K :=
      ⟨⟨⟨⟨⟨p, by intro _ _; exact mul _ _⟩, one⟩,
        by intro _ _; exact add _ _, @add_neg_self K _ 1 ▸ add _ _ one (neg _ one)⟩,
          by intro _; exact neg _⟩, inv⟩
state_before: K : Type u
L : Type v
M : Type w
inst✝² : DivisionRing K
inst✝¹ : DivisionRing L
inst✝ : DivisionRing M
s : Set K
p : K → Prop
x : K
h : x ∈ closure s
mem : ∀ x ∈ s, p x
one : p 1
add : ∀ (x y : K), p x → p y → p (x + y)
neg : ∀ (x : K), p x → p (-x)
inv : ∀ (x : K), p x → p x⁻¹
mul : ∀ (x y : K), p x → p y → p (x * y)
this : Subfield K :=
  { carrier := p, mul_mem' := ⋯, one_mem' := one, add_mem' := ⋯, zero_mem' := ⋯, neg_mem' := ⋯, inv_mem' := inv }
⊢ p x
state_after: no goals
tactic: exact (closure_le (t := this)).2 mem h
Theorem: AddAction.orbitRel.quotient_eq_of_quotient_addSubgroup_eq
File: Mathlib/GroupTheory/GroupAction/Basic.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : ⟦a⟧ = ⟦b⟧
⊢ ⟦a⟧ = ⟦b⟧
state_after: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b
tactic: rw [@Quotient.eq] at h ⊢
state_before: G : Type u_1
α : Type u_2
β : Type u_3
inst✝² : Group G
inst✝¹ : MulAction G α
inst✝ : MulAction G β
H : Subgroup G
a b : α
h : a ≈ b
⊢ a ≈ b
state_after: no goals
tactic: exact mem_orbit_of_mem_orbit_subgroup h
Theorem: symmDiff_sdiff_inf
File: Mathlib/Order/SymmDiff.lean

Proof steps:
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a ∆ b \ (a ⊓ b) = a ∆ b
state_after: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ (b ⊔ a ⊓ b) ⊔ b \ (a ⊔ a ⊓ b) = a ∆ b
tactic: rw [symmDiff_sdiff]
state_before: ι : Type u_1
α : Type u_2
β : Type u_3
π : ι → Type u_4
inst✝ : GeneralizedCoheytingAlgebra α
a b c d : α
⊢ a \ (b ⊔ a ⊓ b) ⊔ b \ (a ⊔ a ⊓ b) = a ∆ b
state_after: no goals
tactic: simp [symmDiff]
Theorem: pow_div_pow_eventuallyEq_atTop
File: Mathlib/Analysis/Asymptotics/SpecificAsymptotics.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ (fun x => x ^ p / x ^ q) =ᶠ[atTop] fun x => x ^ (↑p - ↑q)
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ ∀ (x : 𝕜), 0 < x → (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
tactic: apply (eventually_gt_atTop (0 : 𝕜)).mono fun x hx => _
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
⊢ ∀ (x : 𝕜), 0 < x → (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
state_after: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
x : 𝕜
hx : 0 < x
⊢ (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
tactic: intro x hx
state_before: 𝕜 : Type u_1
inst✝ : LinearOrderedField 𝕜
p q : ℕ
x : 𝕜
hx : 0 < x
⊢ (fun x => x ^ p / x ^ q) x = (fun x => x ^ (↑p - ↑q)) x
state_after: no goals
tactic: simp [zpow_sub₀ hx.ne']
Theorem: CategoryTheory.Limits.Multicofork.condition
File: Mathlib/CategoryTheory/Limits/Shapes/Multiequalizer.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
I : MultispanIndex C
K : Multicofork I
a : I.L
⊢ I.fst a ≫ K.π (I.fstFrom a) = I.snd a ≫ K.π (I.sndFrom a)
state_after: no goals
tactic: rw [← K.snd_app_right, ← K.fst_app_right]
Theorem: Equiv.symm_image_subset
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
e : α ≃ β
s : Set α
t : Set β
⊢ ⇑e.symm '' t ⊆ s ↔ t ⊆ ⇑e '' s
state_after: no goals
tactic: rw [image_subset_iff, e.image_eq_preimage]
Theorem: dense_sInter_of_isOpen
File: Mathlib/Topology/Baire/Lemmas.lean

Proof steps:
state_before: X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
⊢ Dense (⋂₀ S)
state_after: case inl
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S = ∅
⊢ Dense (⋂₀ S)

case inr
X : Type u_1
α : Type u_2
ι : Sort u_3
inst✝¹ : TopologicalSpace X
inst✝ : BaireSpace X
S : Set (Set X)
ho : ∀ s ∈ S, IsOpen s
hS : S.Countable
hd : ∀ s ∈ S, Dense s
h : S.Nonempty
⊢ Dense (⋂₀ S)
tactic: rcases S.eq_empty_or_nonempty with h | h
Theorem: Polynomial.abs_tendsto_atTop
File: Mathlib/Analysis/SpecialFunctions/Polynomials.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
⊢ Tendsto (fun x => |eval x P|) atTop atTop
state_after: case inl
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
hP : 0 ≤ P.leadingCoeff
⊢ Tendsto (fun x => |eval x P|) atTop atTop

case inr
𝕜 : Type u_1
inst✝¹ : NormedLinearOrderedField 𝕜
P Q : 𝕜[X]
inst✝ : OrderTopology 𝕜
hdeg : 0 < P.degree
hP : P.leadingCoeff ≤ 0
⊢ Tendsto (fun x => |eval x P|) atTop atTop
tactic: rcases le_total 0 P.leadingCoeff with hP | hP
Theorem: Orientation.oangle_rotation_oangle_left
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 y : V
⊢ o.oangle ((o.rotation (o.oangle x y)) x) y = 0
state_after: case pos
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 y : V
hx : x = 0
⊢ o.oangle ((o.rotation (o.oangle x y)) x) y = 0

case neg
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 y : V
hx : ¬x = 0
⊢ o.oangle ((o.rotation (o.oangle x y)) x) y = 0
tactic: by_cases hx : x = 0
Theorem: MeasureTheory.locallyIntegrable_comap
File: Mathlib/MeasureTheory/Function/LocallyIntegrable.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hs : MeasurableSet s
⊢ LocallyIntegrable (fun x => f ↑x) (comap Subtype.val μ) ↔ LocallyIntegrableOn f s μ
state_after: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hs : MeasurableSet s
⊢ LocallyIntegrable (fun x => f ↑x) (comap Subtype.val μ) ↔
    ∀ (x : { a // a ∈ s }), IntegrableAtFilter f (Filter.map Subtype.val (𝓝 x)) μ
tactic: simp_rw [LocallyIntegrableOn, Subtype.forall', ← map_nhds_subtype_val]
state_before: X : Type u_1
Y : Type u_2
E : Type u_3
F : Type u_4
R : Type u_5
inst✝⁵ : MeasurableSpace X
inst✝⁴ : TopologicalSpace X
inst✝³ : MeasurableSpace Y
inst✝² : TopologicalSpace Y
inst✝¹ : NormedAddCommGroup E
inst✝ : NormedAddCommGroup F
f g : X → E
μ : Measure X
s : Set X
hs : MeasurableSet s
⊢ LocallyIntegrable (fun x => f ↑x) (comap Subtype.val μ) ↔
    ∀ (x : { a // a ∈ s }), IntegrableAtFilter f (Filter.map Subtype.val (𝓝 x)) μ
state_after: no goals
tactic: exact forall_congr' fun _ ↦ (MeasurableEmbedding.subtype_coe hs).integrableAtFilter_iff_comap.symm
Theorem: MeasureTheory.MeasurePreserving.aestronglyMeasurable_comp_iff
File: Mathlib/MeasureTheory/Function/StronglyMeasurable/Lemmas.lean

Proof steps:
state_before: α : Type u_1
β✝ : Type u_2
γ : Type u_3
m : MeasurableSpace α
μ : Measure α
inst✝¹ : TopologicalSpace β✝
inst✝ : TopologicalSpace γ
f✝ g✝ : α → β✝
β : Type u_4
f : α → β
mα : MeasurableSpace α
μa : Measure α
mβ : MeasurableSpace β
μb : Measure β
hf : MeasurePreserving f μa μb
h₂ : MeasurableEmbedding f
g : β → γ
⊢ AEStronglyMeasurable (g ∘ f) μa ↔ AEStronglyMeasurable g μb
state_after: no goals
tactic: rw [← hf.map_eq, h₂.aestronglyMeasurable_map_iff]
Theorem: Filter.not_eventually
File: Mathlib/Order/Filter/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
p : α → Prop
f : Filter α
⊢ (¬∀ᶠ (x : α) in f, p x) ↔ ∃ᶠ (x : α) in f, ¬p x
state_after: no goals
tactic: simp [Filter.Frequently]
Theorem: max_one_div_max_inv_one_eq_self
File: Mathlib/Algebra/Order/Group/MinMax.lean

Proof steps:
state_before: α : Type u_1
inst✝² : Group α
inst✝¹ : LinearOrder α
inst✝ : CovariantClass α α (fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a : α
⊢ max a 1 / max a⁻¹ 1 = a
state_after: no goals
tactic: rcases le_total a 1 with (h | h) <;> simp [h]
Theorem: WithZero.map_map
File: Mathlib/Algebra/Group/WithOne/Basic.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : Mul α
inst✝¹ : Mul β
inst✝ : Mul γ
f : α →ₙ* β
g : β →ₙ* γ
x : WithOne α
⊢ (map g) ((map f) x) = (map (g.comp f)) x
state_after: no goals
tactic: induction x <;> rfl
Theorem: Polynomial.degree_sub_eq_right_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✝ : Ring R
p q : R[X]
h : p.degree < q.degree
⊢ (p - q).degree = q.degree
state_after: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : p.degree < (-q).degree
⊢ (p - q).degree = q.degree
tactic: rw [← degree_neg q] at h
state_before: R : Type u
S : Type v
a b c d : R
n m : ℕ
inst✝ : Ring R
p q : R[X]
h : p.degree < (-q).degree
⊢ (p - q).degree = q.degree
state_after: no goals
tactic: rw [sub_eq_add_neg, degree_add_eq_right_of_degree_lt h, degree_neg]
Theorem: PNat.card_Ioc
File: Mathlib/Data/PNat/Interval.lean

Proof steps:
state_before: a b : ℕ+
⊢ (Ioc a b).card = ↑b - ↑a
state_after: a b : ℕ+
⊢ (Ioc a b).card = (Ioc ↑a ↑b).card
tactic: rw [← Nat.card_Ioc]
state_before: a b : ℕ+
⊢ (Ioc a b).card = (Ioc ↑a ↑b).card
state_after: a b : ℕ+
⊢ (Ioc a b).card = (map (Embedding.subtype fun n => 0 < n) (Ioc a b)).card
tactic: erw [← Finset.map_subtype_embedding_Ioc _ a b (fun c x _ hx _ hc _ => hc.trans_le hx)]
state_before: a b : ℕ+
⊢ (Ioc a b).card = (map (Embedding.subtype fun n => 0 < n) (Ioc a b)).card
state_after: no goals
tactic: rw [card_map]
Theorem: Matrix.isRegular_of_isLeftRegular_det
File: Mathlib/LinearAlgebra/Matrix/Adjugate.lean

Proof steps:
state_before: m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
hA : IsLeftRegular A.det
⊢ IsRegular A
state_after: case left
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
hA : IsLeftRegular A.det
⊢ IsLeftRegular A

case right
m : Type u
n : Type v
α : Type w
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
inst✝ : CommRing α
A : Matrix n n α
hA : IsLeftRegular A.det
⊢ IsRightRegular A
tactic: constructor
Theorem: variationOnFromTo.monotoneOn
File: Mathlib/Analysis/BoundedVariation.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a : α
as : a ∈ s
⊢ MonotoneOn (variationOnFromTo f s a) s
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a : α
as : a ∈ s
b : α
bs : b ∈ s
c : α
cs : c ∈ s
bc : b ≤ c
⊢ variationOnFromTo f s a b ≤ variationOnFromTo f s a c
tactic: rintro b bs c cs bc
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a : α
as : a ∈ s
b : α
bs : b ∈ s
c : α
cs : c ∈ s
bc : b ≤ c
⊢ variationOnFromTo f s a b ≤ variationOnFromTo f s a c
state_after: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a : α
as : a ∈ s
b : α
bs : b ∈ s
c : α
cs : c ∈ s
bc : b ≤ c
⊢ variationOnFromTo f s a b ≤ variationOnFromTo f s a b + variationOnFromTo f s b c
tactic: rw [← variationOnFromTo.add hf as bs cs]
state_before: α : Type u_1
inst✝¹ : LinearOrder α
E : Type u_2
inst✝ : PseudoEMetricSpace E
f : α → E
s : Set α
hf : LocallyBoundedVariationOn f s
a : α
as : a ∈ s
b : α
bs : b ∈ s
c : α
cs : c ∈ s
bc : b ≤ c
⊢ variationOnFromTo f s a b ≤ variationOnFromTo f s a b + variationOnFromTo f s b c
state_after: no goals
tactic: exact le_add_of_nonneg_right (variationOnFromTo.nonneg_of_le f s bc)
Theorem: WittVector.truncate_mk'
File: Mathlib/RingTheory/WittVector/Truncated.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
⊢ (truncate n) { coeff := f } = TruncatedWittVector.mk p fun k => f ↑k
state_after: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
i : Fin n
⊢ TruncatedWittVector.coeff i ((truncate n) { coeff := f }) =
    TruncatedWittVector.coeff i (TruncatedWittVector.mk p fun k => f ↑k)
tactic: ext i
state_before: case h
p : ℕ
hp : Fact (Nat.Prime p)
n : ℕ
R : Type u_1
inst✝ : CommRing R
f : ℕ → R
i : Fin n
⊢ TruncatedWittVector.coeff i ((truncate n) { coeff := f }) =
    TruncatedWittVector.coeff i (TruncatedWittVector.mk p fun k => f ↑k)
state_after: no goals
tactic: simp only [coeff_truncate, TruncatedWittVector.coeff_mk]
Theorem: CategoryTheory.Functor.ShiftSequence.induced.shiftIso_hom_app_obj
File: Mathlib/CategoryTheory/Shift/InducedShiftSequence.lean

Proof steps:
state_before: C : Type u_1
D : Type u_2
A : Type u_3
inst✝⁹ : Category.{u_7, u_1} C
inst✝⁸ : Category.{u_6, u_2} D
inst✝⁷ : Category.{u_5, u_3} A
L : C ⥤ D
F : D ⥤ A
G : C ⥤ A
e : L ⋙ F ≅ G
M : Type u_4
inst✝⁶ : AddMonoid M
inst✝⁵ : HasShift C M
inst✝⁴ : HasShift D M
inst✝³ : L.CommShift M
inst✝² : G.ShiftSequence M
F' : M → D ⥤ A
e' : (m : M) → L ⋙ F' m ≅ G.shift m
inst✝¹ : ((whiskeringLeft C D A).obj L).Full
inst✝ : ((whiskeringLeft C D A).obj L).Faithful
n a a' : M
ha' : n + a = a'
X : C
⊢ ((L.associator (shiftFunctor D n) (F' a)).symm ≪≫
            isoWhiskerRight (L.commShiftIso n).symm (F' a) ≪≫
              (shiftFunctor C n).associator L (F' a) ≪≫
                isoWhiskerLeft (shiftFunctor C n) (e' a) ≪≫ G.shiftIso n a a' ha' ≪≫ (e' a').symm).hom.app
      X =
    (F' a).map ((L.commShiftIso n).inv.app X) ≫
      (e' a).hom.app ((shiftFunctor C n).obj X) ≫ (G.shiftIso n a a' ha').hom.app X ≫ (e' a').inv.app X
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ShortComplex.moduleCatMkOfKerLERange_X₃
File: Mathlib/Algebra/Homology/ShortComplex/ModuleCat.lean

Proof steps:
state_before: R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
⊢ f ≫ g = 0
state_after: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
x✝ : ↑X₁
⊢ (f ≫ g) x✝ = 0 x✝
tactic: ext
state_before: case h
R : Type u
inst✝ : Ring R
S : ShortComplex (ModuleCat R)
X₁ X₂ X₃ : ModuleCat R
f : X₁ ⟶ X₂
g : X₂ ⟶ X₃
hfg : LinearMap.range f ≤ LinearMap.ker g
x✝ : ↑X₁
⊢ (f ≫ g) x✝ = 0 x✝
state_after: no goals
tactic: exact hfg ⟨_, rfl⟩