ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Representation.linHom.invariantsEquivRepHom_symm_apply_coe
File: Mathlib/RepresentationTheory/Invariants.lean

Proof steps:
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝ : ↥(X.ρ.linHom Y.ρ).invariants
⊢ (fun f => ⟨f.hom, ⋯⟩) ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun x✝) = x✝
state_after: case a
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝ : ↥(X.ρ.linHom Y.ρ).invariants
⊢ ↑((fun f => ⟨f.hom, ⋯⟩) ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun x✝)) =
    ↑x✝
tactic: apply Subtype.ext
state_before: case a
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝ : ↥(X.ρ.linHom Y.ρ).invariants
⊢ ↑((fun f => ⟨f.hom, ⋯⟩) ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun x✝)) =
    ↑x✝
state_after: case a.h
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝¹ : ↥(X.ρ.linHom Y.ρ).invariants
x✝ : CoeSort.coe X
⊢ ↑((fun f => ⟨f.hom, ⋯⟩) ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun x✝¹))
      x✝ =
    ↑x✝¹ x✝
tactic: ext
state_before: case a.h
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝¹ : ↥(X.ρ.linHom Y.ρ).invariants
x✝ : CoeSort.coe X
⊢ ↑((fun f => ⟨f.hom, ⋯⟩) ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun x✝¹))
      x✝ =
    ↑x✝¹ x✝
state_after: no goals
tactic: rfl
state_before: k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝ : X ⟶ Y
⊢ { toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun ((fun f => ⟨f.hom, ⋯⟩) x✝) = x✝
state_after: case h.h
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝¹ : X ⟶ Y
x✝ : ↑X.V
⊢ ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun ((fun f => ⟨f.hom, ⋯⟩) x✝¹)).hom
      x✝ =
    x✝¹.hom x✝
tactic: ext
state_before: case h.h
k : Type u
inst✝ : CommRing k
G : Grp
X Y : Rep k ↑G
x✝¹ : X ⟶ Y
x✝ : ↑X.V
⊢ ({ toFun := fun f => { hom := ↑f, comm := ⋯ }, map_add' := ⋯, map_smul' := ⋯ }.toFun ((fun f => ⟨f.hom, ⋯⟩) x✝¹)).hom
      x✝ =
    x✝¹.hom x✝
state_after: no goals
tactic: rfl
Theorem: CategoryTheory.PreOneHypercover.map_I₀
File: Mathlib/CategoryTheory/Sites/Continuous.lean

Proof steps:
state_before: C : Type u₁
inst✝² : Category.{v₁, u₁} C
D : Type u₂
inst✝¹ : Category.{v₂, u₂} D
E✝ : Type u₃
inst✝ : Category.{v₃, u₃} E✝
X : C
E : PreOneHypercover X
F : C ⥤ D
x✝¹ x✝ : E.I₀
j : E.I₁ x✝¹ x✝
⊢ (fun x x_1 j => F.map (E.p₁ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝¹ =
    (fun x x_1 j => F.map (E.p₂ j)) x✝¹ x✝ j ≫ (fun i => F.map (E.f i)) x✝
state_after: no goals
tactic: simpa using F.congr_map (E.w j)
Theorem: Relation.ReflTransGen.total_of_right_unique
File: Mathlib/Logic/Relation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
U : Relator.RightUnique r
ab : ReflTransGen r a b
ac : ReflTransGen r a c
⊢ ReflTransGen r b c ∨ ReflTransGen r c b
state_after: case refl
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b c d : α
U : Relator.RightUnique r
ac : ReflTransGen r a c
⊢ ReflTransGen r a c ∨ ReflTransGen r c a

case tail
α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ε : Type u_5
ζ : Type u_6
r : α → α → Prop
a b✝ c d✝ : α
U : Relator.RightUnique r
ac : ReflTransGen r a c
b d : α
a✝ : ReflTransGen r a b
bd : r b d
IH : ReflTransGen r b c ∨ ReflTransGen r c b
⊢ ReflTransGen r d c ∨ ReflTransGen r c d
tactic: induction' ab with b d _ bd IH
Theorem: Submodule.isCompl_comap_subtype_of_isCompl_of_le
File: Mathlib/LinearAlgebra/Span.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
K : Type u_3
M : Type u_4
M₂ : Type u_5
V : Type u_6
S : Type u_7
inst✝² : Ring R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
p q r : Submodule R M
h₁ : IsCompl q r
h₂ : q ≤ p
⊢ IsCompl (comap p.subtype q) (comap p.subtype r)
state_after: no goals
tactic: simpa [p.mapIic.isCompl_iff, Iic.isCompl_iff] using Iic.isCompl_inf_inf_of_isCompl_of_le h₁ h₂
Theorem: CauSeq.sub_limZero
File: Mathlib/Algebra/Order/CauSeq/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : LinearOrderedField α
inst✝¹ : Ring β
abv : β → α
inst✝ : IsAbsoluteValue abv
f g : CauSeq β abv
hf : f.LimZero
hg : g.LimZero
⊢ (f - g).LimZero
state_after: no goals
tactic: simpa only [sub_eq_add_neg] using add_limZero hf (neg_limZero hg)
Theorem: CategoryTheory.Functor.conj_eqToHom_iff_heq
File: Mathlib/CategoryTheory/EqToHom.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Y Z : C
f : W ⟶ X
g : Y ⟶ Z
h : W = Y
h' : X = Z
⊢ f = eqToHom h ≫ g ≫ eqToHom ⋯ ↔ HEq f g
state_after: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Z : C
f : W ⟶ X
h' : X = Z
g : W ⟶ Z
⊢ f = eqToHom ⋯ ≫ g ≫ eqToHom ⋯ ↔ HEq f g
tactic: cases h
state_before: case refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X Z : C
f : W ⟶ X
h' : X = Z
g : W ⟶ Z
⊢ f = eqToHom ⋯ ≫ g ≫ eqToHom ⋯ ↔ HEq f g
state_after: case refl.refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X : C
f g : W ⟶ X
⊢ f = eqToHom ⋯ ≫ g ≫ eqToHom ⋯ ↔ HEq f g
tactic: cases h'
state_before: case refl.refl
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
β : Sort u_1
D : Type u₂
inst✝ : Category.{v₂, u₂} D
W X : C
f g : W ⟶ X
⊢ f = eqToHom ⋯ ≫ g ≫ eqToHom ⋯ ↔ HEq f g
state_after: no goals
tactic: simp
Theorem: Set.image2_union_inter_subset
File: Mathlib/Data/Set/NAry.lean

Proof steps:
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → α → β
s t : Set α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (s ∪ t) (s ∩ t) ⊆ image2 f s t
state_after: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → α → β
s t : Set α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (s ∩ t) (s ∪ t) ⊆ image2 f s t
tactic: rw [image2_comm hf]
state_before: α : Type u_1
α' : Type u_2
β : Type u_3
β' : Type u_4
γ : Type u_5
γ' : Type u_6
δ : Type u_7
δ' : Type u_8
ε : Type u_9
ε' : Type u_10
ζ : Type u_11
ζ' : Type u_12
ν : Type u_13
f✝ f' : α → β → γ
g g' : α → β → γ → δ
s✝ s' : Set α
t✝ t' : Set β
u u' : Set γ
v : Set δ
a a' : α
b b' : β
c c' : γ
d d' : δ
f : α → α → β
s t : Set α
hf : ∀ (a b : α), f a b = f b a
⊢ image2 f (s ∩ t) (s ∪ t) ⊆ image2 f s t
state_after: no goals
tactic: exact image2_inter_union_subset hf
Theorem: PEquiv.trans_bot
File: Mathlib/Data/PEquiv.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
⊢ f.trans ⊥ = ⊥
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f.trans ⊥) x✝ ↔ a✝ ∈ ⊥ x✝
tactic: ext
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f.trans ⊥) x✝ ↔ a✝ ∈ ⊥ x✝
state_after: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f x✝).bind ⇑⊥ ↔ a✝ ∈ none
tactic: dsimp [PEquiv.trans]
state_before: case h.a
α : Type u
β : Type v
γ : Type w
δ : Type x
f : α ≃. β
x✝ : α
a✝ : γ
⊢ a✝ ∈ (f x✝).bind ⇑⊥ ↔ a✝ ∈ none
state_after: no goals
tactic: simp
Theorem: Setoid.classes_inj
File: Mathlib/Data/Setoid/Partition.lean

Proof steps:
state_before: α : Type u_1
r₁ r₂ : Setoid α
h : r₁.classes = r₂.classes
a b : α
⊢ r₁.Rel a b ↔ r₂.Rel a b
state_after: no goals
tactic: simp only [rel_iff_exists_classes, exists_prop, h]
Theorem: IsSepClosed.exists_eq_mul_self
File: Mathlib/FieldTheory/IsSepClosed.lean

Proof steps:
state_before: k : Type u
inst✝² : Field k
K : Type v
inst✝¹ : Field K
inst✝ : IsSepClosed k
x : k
h2 : NeZero 2
⊢ ∃ z, x = z * z
state_after: case intro
k : Type u
inst✝² : Field k
K : Type v
inst✝¹ : Field K
inst✝ : IsSepClosed k
h2 : NeZero 2
z : k
⊢ ∃ z_1, z ^ 2 = z_1 * z_1
tactic: rcases exists_pow_nat_eq x 2 with ⟨z, rfl⟩
state_before: case intro
k : Type u
inst✝² : Field k
K : Type v
inst✝¹ : Field K
inst✝ : IsSepClosed k
h2 : NeZero 2
z : k
⊢ ∃ z_1, z ^ 2 = z_1 * z_1
state_after: no goals
tactic: exact ⟨z, sq z⟩
Theorem: Metric.diam_union'
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
x y z : α
t : Set α
h : (s ∩ t).Nonempty
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
x✝ y z : α
t : Set α
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t
tactic: rcases h with ⟨x, ⟨xs, xt⟩⟩
state_before: case intro.intro
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
s : Set α
x✝ y z : α
t : Set α
x : α
xs : x ∈ s
xt : x ∈ t
⊢ diam (s ∪ t) ≤ diam s + diam t
state_after: no goals
tactic: simpa using diam_union xs xt
Theorem: ENNReal.le_of_forall_nnreal_lt
File: Mathlib/Data/ENNReal/Inv.lean

Proof steps:
state_before: a b c d : ℝ≥0∞
r p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
⊢ x ≤ y
state_after: a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0∞
hr : r < x
⊢ r ≤ y
tactic: refine le_of_forall_ge_of_dense fun r hr => ?_
state_before: a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0∞
hr : r < x
⊢ r ≤ y
state_after: case intro
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0
hr : ↑r < x
⊢ ↑r ≤ y
tactic: lift r to ℝ≥0 using ne_top_of_lt hr
state_before: case intro
a b c d : ℝ≥0∞
r✝ p q : ℝ≥0
x y : ℝ≥0∞
h : ∀ (r : ℝ≥0), ↑r < x → ↑r ≤ y
r : ℝ≥0
hr : ↑r < x
⊢ ↑r ≤ y
state_after: no goals
tactic: exact h r hr
Theorem: Nat.Subtype.succ_le_of_lt
File: Mathlib/Logic/Denumerable.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s : Set ℕ
inst✝¹ : Infinite ↑s
inst✝ : DecidablePred fun x => x ∈ s
x y : ↑s
h : y < x
hx : ∃ m, ↑y + m + 1 ∈ s
k : ℕ
hk : ↑x = ↑y + k + 1
this : Nat.find hx ≤ k
⊢ ↑y + Nat.find hx + 1 ≤ ↑x
state_after: no goals
tactic: omega
Theorem: NumberField.InfinitePlace.one_le_of_lt_one
File: Mathlib/NumberTheory/NumberField/Embeddings.lean

Proof steps:
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
a : 𝓞 K
ha : a ≠ 0
h : ∀ ⦃z : InfinitePlace K⦄, z ≠ w → z ↑a < 1
⊢ 1 ≤ ↑|(Algebra.norm ℚ) ↑a|
state_after: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
a : 𝓞 K
ha : a ≠ 0
h : ∀ ⦃z : InfinitePlace K⦄, z ≠ w → z ↑a < 1
⊢ 1 ≤ |(Algebra.norm ℤ) a|
tactic: rw [← Algebra.coe_norm_int, ← Int.cast_one, ← Int.cast_abs, Rat.cast_intCast, Int.cast_le]
state_before: k : Type u_1
inst✝³ : Field k
K : Type u_2
inst✝² : Field K
F : Type u_3
inst✝¹ : Field F
inst✝ : NumberField K
w : InfinitePlace K
a : 𝓞 K
ha : a ≠ 0
h : ∀ ⦃z : InfinitePlace K⦄, z ≠ w → z ↑a < 1
⊢ 1 ≤ |(Algebra.norm ℤ) a|
state_after: no goals
tactic: exact Int.one_le_abs (Algebra.norm_ne_zero_iff.mpr ha)
Theorem: CategoryTheory.Limits.map_π_preserves_coequalizer_inv_colimMap
File: Mathlib/CategoryTheory/Limits/Preserves/Shapes/Equalizers.lean

Proof steps:
state_before: C : Type u₁
inst✝⁵ : Category.{v₁, u₁} C
D : Type u₂
inst✝⁴ : Category.{v₂, u₂} D
G : C ⥤ D
X Y Z : C
f g : X ⟶ Y
h : Y ⟶ Z
w : f ≫ h = g ≫ h
inst✝³ : HasCoequalizer f g
inst✝² : HasCoequalizer (G.map f) (G.map g)
inst✝¹ : PreservesColimit (parallelPair f g) G
X' Y' : D
f' g' : X' ⟶ Y'
inst✝ : HasCoequalizer f' g'
p : G.obj X ⟶ X'
q : G.obj Y ⟶ Y'
wf : G.map f ≫ q = p ≫ f'
wg : G.map g ≫ q = p ≫ g'
⊢ G.map (coequalizer.π f g) ≫
      (PreservesCoequalizer.iso G f g).inv ≫ colimMap (parallelPairHom (G.map f) (G.map g) f' g' p q wf wg) =
    q ≫ coequalizer.π f' g'
state_after: no goals
tactic: rw [← Category.assoc, map_π_preserves_coequalizer_inv, ι_colimMap, parallelPairHom_app_one]
Theorem: AlgebraicGeometry.IsOpenImmersion.ΓIso_inv
File: Mathlib/AlgebraicGeometry/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U : Y.Opens
⊢ f ⁻¹ᵁ U ≤ f ⁻¹ᵁ (Scheme.Hom.opensRange f ⊓ U)
state_after: no goals
tactic: rw [← f.image_preimage_eq_opensRange_inter, f.preimage_image_eq]
state_before: C : Type u
inst✝¹ : Category.{v, u} C
X✝ Y✝ Z : Scheme
f✝ : X✝ ⟶ Z
g : Y✝ ⟶ Z
H : IsOpenImmersion f✝
X Y : Scheme
f : X ⟶ Y
inst✝ : IsOpenImmersion f
U : Y.Opens
⊢ (ΓIso f U).inv = Scheme.Hom.appLE f (Scheme.Hom.opensRange f ⊓ U) (f ⁻¹ᵁ U) ⋯
state_after: no goals
tactic: simp only [ΓIso, Iso.trans_inv, Functor.mapIso_inv, Iso.op_inv, eqToIso.inv, eqToHom_op,
    asIso_inv, IsIso.comp_inv_eq, Iso.symm_inv, Scheme.Hom.appIso_hom', Scheme.Hom.map_appLE]
Theorem: MonoidHom.compLeft_apply
File: Mathlib/Algebra/Group/Pi/Lemmas.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
⊢ (fun h => ⇑f ∘ h) 1 = 1
state_after: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝ : I
⊢ (fun h => ⇑f ∘ h) 1 x✝ = 1 x✝
tactic: ext
state_before: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝ : I
⊢ (fun h => ⇑f ∘ h) 1 x✝ = 1 x✝
state_after: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝ : I
⊢ f 1 = 1
tactic: dsimp
state_before: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝ : I
⊢ f 1 = 1
state_after: no goals
tactic: simp
state_before: ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝¹ x✝ : I → α
⊢ { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun (x✝¹ * x✝) =
    { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝¹ * { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝
state_after: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝² x✝¹ : I → α
x✝ : I
⊢ { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun (x✝² * x✝¹) x✝ =
    ({ toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝² * { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝¹) x✝
tactic: ext
state_before: case h
ι : Type u_1
α✝ : Type u_2
I✝ : Type u
f✝ : I✝ → Type v
x y : (i : I✝) → f✝ i
i j : I✝
inst✝² : (i : I✝) → MulOneClass (f✝ i)
α : Type u_3
β : Type u_4
inst✝¹ : MulOneClass α
inst✝ : MulOneClass β
f : α →* β
I : Type u_5
x✝² x✝¹ : I → α
x✝ : I
⊢ { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun (x✝² * x✝¹) x✝ =
    ({ toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝² * { toFun := fun h => ⇑f ∘ h, map_one' := ⋯ }.toFun x✝¹) x✝
state_after: no goals
tactic: simp
Theorem: LocalizedModule.mem_ker_mkLinearMap_iff
File: Mathlib/Algebra/Module/LocalizedModule.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
S : Submonoid R
m : M
⊢ m ∈ LinearMap.ker (mkLinearMap S M) ↔ ∃ r ∈ S, r • m = 0
state_after: case mp
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
S : Submonoid R
m : M
⊢ m ∈ LinearMap.ker (mkLinearMap S M) → ∃ r ∈ S, r • m = 0

case mpr
R : Type u_1
M : Type u_2
inst✝² : CommRing R
inst✝¹ : AddCommGroup M
inst✝ : Module R M
S : Submonoid R
m : M
⊢ (∃ r ∈ S, r • m = 0) → m ∈ LinearMap.ker (mkLinearMap S M)
tactic: constructor
Theorem: Multiset.fold_bind
File: Mathlib/Data/Multiset/Fold.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
ι : Type u_3
s : Multiset ι
t : ι → Multiset α
b : ι → α
b₀ : α
⊢ fold op (fold op b₀ (map b s)) (s.bind t) = fold op b₀ (map (fun i => fold op (b i) (t i)) s)
state_after: case empty
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
⊢ fold op (fold op b₀ (map b 0)) (bind 0 t) = fold op b₀ (map (fun i => fold op (b i) (t i)) 0)

case cons
α : Type u_1
β : Type u_2
op : α → α → α
hc : Std.Commutative op
ha✝ : Std.Associative op
ι : Type u_3
t : ι → Multiset α
b : ι → α
b₀ : α
a : ι
ha : Multiset ι
ih : fold op (fold op b₀ (map b ha)) (ha.bind t) = fold op b₀ (map (fun i => fold op (b i) (t i)) ha)
⊢ fold op (fold op b₀ (map b (a ::ₘ ha))) ((a ::ₘ ha).bind t) =
    fold op b₀ (map (fun i => fold op (b i) (t i)) (a ::ₘ ha))
tactic: induction' s using Multiset.induction_on with a ha ih
Theorem: FreeGroup.Red.to_append_iff
File: Mathlib/GroupTheory/FreeGroup/Basic.lean

Proof steps:
state_before: α : Type u
L L₁ L₂ L₃ L₄ : List (α × Bool)
⊢ Red L (L₁ ++ L₂) → ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
state_after: α : Type u
L L₁ L₂ L₃ L₄ L₁₂ : List (α × Bool)
eq : L₁ ++ L₂ = L₁₂
⊢ Red L L₁₂ → ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
tactic: generalize eq : L₁ ++ L₂ = L₁₂
state_before: α : Type u
L L₁ L₂ L₃ L₄ L₁₂ : List (α × Bool)
eq : L₁ ++ L₂ = L₁₂
⊢ Red L L₁₂ → ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
state_after: α : Type u
L L₁ L₂ L₃ L₄ L₁₂ : List (α × Bool)
eq : L₁ ++ L₂ = L₁₂
h : Red L L₁₂
⊢ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
tactic: intro h
state_before: α : Type u
L L₁ L₂ L₃ L₄ L₁₂ : List (α × Bool)
eq : L₁ ++ L₂ = L₁₂
h : Red L L₁₂
⊢ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
state_after: case refl
α : Type u
L L₃ L₄ L₁₂ L₁ L₂ : List (α × Bool)
eq : L₁ ++ L₂ = L
⊢ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂

case tail
α : Type u
L L₃ L₄ L₁₂✝ L' L₁₂ : List (α × Bool)
hLL' : ReflTransGen Step L L'
h : Step L' L₁₂
ih : ∀ {L₁ L₂ : List (α × Bool)}, L₁ ++ L₂ = L' → ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
L₁ L₂ : List (α × Bool)
eq : L₁ ++ L₂ = L₁₂
⊢ ∃ L₃ L₄, L = L₃ ++ L₄ ∧ Red L₃ L₁ ∧ Red L₄ L₂
tactic: induction' h with L' L₁₂ hLL' h ih generalizing L₁ L₂
Theorem: Orientation.areaForm_rightAngleRotation_right
File: Mathlib/Analysis/InnerProductSpace/TwoDim.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : InnerProductSpace ℝ E
inst✝ : Fact (finrank ℝ E = 2)
o : Orientation ℝ E (Fin 2)
x y : E
⊢ (o.areaForm x) (o.rightAngleRotation y) = ⟪x, y⟫_ℝ
state_after: no goals
tactic: rw [← o.inner_rightAngleRotation_left, o.inner_comp_rightAngleRotation]
Theorem: MeasureTheory.withDensity_apply_eq_zero'
File: Mathlib/MeasureTheory/Measure/WithDensity.lean

Proof steps:
state_before: α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f μ
⊢ (μ.withDensity f) s = 0 ↔ μ ({x | f x ≠ 0} ∩ s) = 0
state_after: case mp
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f μ
⊢ (μ.withDensity f) s = 0 → μ ({x | f x ≠ 0} ∩ s) = 0

case mpr
α : Type u_1
m0 : MeasurableSpace α
μ : Measure α
f : α → ℝ≥0∞
s : Set α
hf : AEMeasurable f μ
⊢ μ ({x | f x ≠ 0} ∩ s) = 0 → (μ.withDensity f) s = 0
tactic: constructor
Theorem: Polynomial.derivative_eval₂_C
File: Mathlib/Algebra/Polynomial/Derivative.lean

Proof steps:
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
p q : R[X]
r : R
⊢ derivative (eval₂ C q (C r)) = eval₂ C q (derivative (C r)) * derivative q
state_after: no goals
tactic: rw [eval₂_C, derivative_C, eval₂_zero, zero_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n : ℕ
inst✝ : CommSemiring R
p q p₁ p₂ : R[X]
ih₁ : derivative (eval₂ C q p₁) = eval₂ C q (derivative p₁) * derivative q
ih₂ : derivative (eval₂ C q p₂) = eval₂ C q (derivative p₂) * derivative q
⊢ derivative (eval₂ C q (p₁ + p₂)) = eval₂ C q (derivative (p₁ + p₂)) * derivative q
state_after: no goals
tactic: rw [eval₂_add, derivative_add, ih₁, ih₂, derivative_add, eval₂_add, add_mul]
state_before: R : Type u
S : Type v
T : Type w
ι : Type y
A : Type z
a b : R
n✝ : ℕ
inst✝ : CommSemiring R
p q : R[X]
n : ℕ
r : R
ih : derivative (eval₂ C q (C r * X ^ n)) = eval₂ C q (derivative (C r * X ^ n)) * derivative q
⊢ derivative (eval₂ C q (C r * X ^ (n + 1))) = eval₂ C q (derivative (C r * X ^ (n + 1))) * derivative q
state_after: no goals
tactic: rw [pow_succ, ← mul_assoc, eval₂_mul, eval₂_X, derivative_mul, ih, @derivative_mul _ _ _ X,
      derivative_X, mul_one, eval₂_add, @eval₂_mul _ _ _ _ X, eval₂_X, add_mul, mul_right_comm]
Theorem: CauSeq.lim_mul_lim
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
⊢ (const abv (f.lim * g.lim) - f * g).LimZero
state_after: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (f.lim * g.lim) - f * g = (const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)
⊢ (const abv (f.lim * g.lim) - f * g).LimZero
tactic: have h :
        const abv (lim f * lim g) - f * g =
          (const abv (lim f) - f) * g + const abv (lim f) * (const abv (lim g) - g) := by
              apply Subtype.ext
              rw [coe_add]
              simp [sub_mul, mul_sub]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (f.lim * g.lim) - f * g = (const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)
⊢ (const abv (f.lim * g.lim) - f * g).LimZero
state_after: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (f.lim * g.lim) - f * g = (const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)
⊢ ((const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)).LimZero
tactic: rw [h]
state_before: α : Type u_1
inst✝³ : LinearOrderedField α
β : Type u_2
inst✝² : Ring β
abv : β → α
inst✝¹ : IsAbsoluteValue abv
inst✝ : IsComplete β abv
f g : CauSeq β abv
h : const abv (f.lim * g.lim) - f * g = (const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)
⊢ ((const abv f.lim - f) * g + const abv f.lim * (const abv g.lim - g)).LimZero
state_after: no goals
tactic: exact
        add_limZero (mul_limZero_left _ (Setoid.symm (equiv_lim _)))
          (mul_limZero_right _ (Setoid.symm (equiv_lim _)))