ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: CategoryTheory.ShortComplex.leftHomologyMapIso_hom
File: Mathlib/Algebra/Homology/ShortComplex/LeftHomology.lean

Proof steps:
state_before: C : Type u_1
inst✝³ : Category.{?u.117978, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
inst✝¹ : S₁.HasLeftHomology
inst✝ : S₂.HasLeftHomology
⊢ leftHomologyMap e.hom ≫ leftHomologyMap e.inv = 𝟙 S₁.leftHomology
state_after: no goals
tactic: rw [← leftHomologyMap_comp, e.hom_inv_id, leftHomologyMap_id]
state_before: C : Type u_1
inst✝³ : Category.{?u.117978, u_1} C
inst✝² : HasZeroMorphisms C
S S₁ S₂ S₃ : ShortComplex C
e : S₁ ≅ S₂
inst✝¹ : S₁.HasLeftHomology
inst✝ : S₂.HasLeftHomology
⊢ leftHomologyMap e.inv ≫ leftHomologyMap e.hom = 𝟙 S₂.leftHomology
state_after: no goals
tactic: rw [← leftHomologyMap_comp, e.inv_hom_id, leftHomologyMap_id]
Theorem: Seminorm.smul_inf
File: Mathlib/Analysis/Seminorm.lean

Proof steps:
state_before: R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x : E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : Seminorm 𝕜 E
⊢ r • (p ⊓ q) = r • p ⊓ r • q
state_after: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x : E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : Seminorm 𝕜 E
x✝ : E
⊢ (r • (p ⊓ q)) x✝ = (r • p ⊓ r • q) x✝
tactic: ext
state_before: case h
R : Type u_1
R' : Type u_2
𝕜 : Type u_3
𝕜₂ : Type u_4
𝕜₃ : Type u_5
𝕝 : Type u_6
E : Type u_7
E₂ : Type u_8
E₃ : Type u_9
F : Type u_10
G : Type u_11
ι : Type u_12
inst✝⁵ : NormedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : Module 𝕜 E
p✝ q✝ : Seminorm 𝕜 E
x : E
inst✝² : SMul R ℝ
inst✝¹ : SMul R ℝ≥0
inst✝ : IsScalarTower R ℝ≥0 ℝ
r : R
p q : Seminorm 𝕜 E
x✝ : E
⊢ (r • (p ⊓ q)) x✝ = (r • p ⊓ r • q) x✝
state_after: no goals
tactic: simp_rw [smul_apply, inf_apply, smul_apply, ← smul_one_smul ℝ≥0 r (_ : ℝ), NNReal.smul_def,
    smul_eq_mul, Real.mul_iInf_of_nonneg (NNReal.coe_nonneg _), mul_add]
Theorem: Nat.eq_sq_add_sq_iff_eq_sq_mul
File: Mathlib/NumberTheory/SumTwoSquares.lean

Proof steps:
state_before: n : ℕ
⊢ (∃ x y, n = x ^ 2 + y ^ 2) ↔ ∃ a b, n = a ^ 2 * b ∧ IsSquare (-1)
state_after: case mp
n : ℕ
⊢ (∃ x y, n = x ^ 2 + y ^ 2) → ∃ a b, n = a ^ 2 * b ∧ IsSquare (-1)

case mpr
n : ℕ
⊢ (∃ a b, n = a ^ 2 * b ∧ IsSquare (-1)) → ∃ x y, n = x ^ 2 + y ^ 2
tactic: constructor
Theorem: AddSubmonoid.addUnitsTypeEquivIsAddUnitAddSubmonoid_apply_coe
File: Mathlib/Algebra/Group/Submonoid/Operations.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x : ↥(IsUnit.submonoid M)
⊢ (fun x => ⟨↑x, ⋯⟩) ((fun x => IsUnit.unit ⋯) x) = x
state_after: no goals
tactic: simp_rw [IsUnit.unit_spec]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun (x * y) =
    { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun x *
      { toFun := fun x => ⟨↑x, ⋯⟩, invFun := fun x => IsUnit.unit ⋯, left_inv := ⋯, right_inv := ⋯ }.toFun y
state_after: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
tactic: simp_rw [Units.val_mul]
state_before: M : Type u_1
N : Type u_2
P : Type u_3
inst✝⁴ : MulOneClass M
inst✝³ : MulOneClass N
inst✝² : MulOneClass P
S : Submonoid M
A : Type u_4
inst✝¹ : SetLike A M
hA : SubmonoidClass A M
S' : A
inst✝ : Monoid M
x y : Mˣ
⊢ ⟨↑x * ↑y, ⋯⟩ = ⟨↑x, ⋯⟩ * ⟨↑y, ⋯⟩
state_after: no goals
tactic: rfl
Theorem: Cubic.b_of_eq
File: Mathlib/Algebra/CubicDiscriminant.lean

Proof steps:
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P Q : Cubic R
a b c d a' b' c' d' : R
inst✝ : Semiring R
h : P.toPoly = Q.toPoly
⊢ P.b = Q.b
state_after: no goals
tactic: rw [← coeff_eq_b, h, coeff_eq_b]
Theorem: Multiset.foldl_induction'
File: Mathlib/Data/Multiset/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type v
γ : Type u_2
f : β → α → β
H : RightCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)
px : p x
q_s : ∀ a ∈ s, q a
⊢ p (foldl f H x s)
state_after: α : Type u_1
β : Type v
γ : Type u_2
f : β → α → β
H : RightCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)
px : p x
q_s : ∀ a ∈ s, q a
⊢ p (foldr (fun x y => f y x) ⋯ x s)
tactic: rw [foldl_swap]
state_before: α : Type u_1
β : Type v
γ : Type u_2
f : β → α → β
H : RightCommutative f
x : β
q : α → Prop
p : β → Prop
s : Multiset α
hpqf : ∀ (a : α) (b : β), q a → p b → p (f b a)
px : p x
q_s : ∀ a ∈ s, q a
⊢ p (foldr (fun x y => f y x) ⋯ x s)
state_after: no goals
tactic: exact foldr_induction' (fun x y => f y x) (fun x y z => (H _ _ _).symm) x q p s hpqf px q_s
Theorem: gradient_eq_deriv
File: Mathlib/Analysis/Calculus/Gradient/Basic.lean

Proof steps:
state_before: 𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
⊢ ∇ g u = (starRingEnd 𝕜) (deriv g u)
state_after: case pos
𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
h : DifferentiableAt 𝕜 g u
⊢ ∇ g u = (starRingEnd 𝕜) (deriv g u)

case neg
𝕜 : Type u_1
F : Type u_2
inst✝³ : RCLike 𝕜
inst✝² : NormedAddCommGroup F
inst✝¹ : InnerProductSpace 𝕜 F
inst✝ : CompleteSpace F
f : F → 𝕜
f' x : F
s : Set F
L : Filter F
g : 𝕜 → 𝕜
g' u : 𝕜
L' : Filter 𝕜
h : ¬DifferentiableAt 𝕜 g u
⊢ ∇ g u = (starRingEnd 𝕜) (deriv g u)
tactic: by_cases h : DifferentiableAt 𝕜 g u
Theorem: Disjoint.disjoint_sup_right_of_disjoint_sup_left
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ Disjoint a (b ⊔ c)
state_after: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ a ⊓ b
tactic: rw [disjoint_iff_inf_le, ← h.eq_bot, sup_comm]
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ a ⊓ b
state_after: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ b
tactic: apply le_inf inf_le_left
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ a ⊓ (c ⊔ b) ≤ b
state_after: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ (?m.25858 ⊔ a) ⊓ (c ⊔ b) ≤ b

α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ α
tactic: apply (inf_le_inf_right (c ⊔ b) le_sup_right).trans
state_before: α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ (?m.25858 ⊔ a) ⊓ (c ⊔ b) ≤ b

α : Type u_1
a b c : α
inst✝² : Lattice α
inst✝¹ : OrderBot α
inst✝ : IsModularLattice α
h : Disjoint a b
hsup : Disjoint (a ⊔ b) c
⊢ α
state_after: no goals
tactic: rw [sup_comm, IsModularLattice.sup_inf_sup_assoc, hsup.eq_bot, bot_sup_eq]
Theorem: EReal.image_coe_Ico
File: Mathlib/Data/Real/EReal.lean

Proof steps:
state_before: x y : ℝ
⊢ Real.toEReal '' Ico x y = Ico ↑x ↑y
state_after: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ico x y) = Ico ↑x ↑y
tactic: refine (image_comp WithBot.some WithTop.some _).trans ?_
state_before: x y : ℝ
⊢ WithBot.some '' (WithTop.some '' Ico x y) = Ico ↑x ↑y
state_after: x y : ℝ
⊢ Ico ↑↑x ↑↑y = Ico ↑x ↑y
tactic: rw [WithTop.image_coe_Ico, WithBot.image_coe_Ico]
state_before: x y : ℝ
⊢ Ico ↑↑x ↑↑y = Ico ↑x ↑y
state_after: no goals
tactic: rfl
Theorem: antitoneOn_of_deriv_nonpos
File: Mathlib/Analysis/Calculus/MeanValue.lean

Proof steps:
state_before: E : Type u_1
inst✝³ : NormedAddCommGroup E
inst✝² : NormedSpace ℝ E
F : Type u_2
inst✝¹ : NormedAddCommGroup F
inst✝ : NormedSpace ℝ F
D : Set ℝ
hD : Convex ℝ D
f : ℝ → ℝ
hf : ContinuousOn f D
hf' : DifferentiableOn ℝ f (interior D)
hf'_nonpos : ∀ x ∈ interior D, deriv f x ≤ 0
x : ℝ
hx : x ∈ D
y : ℝ
hy : y ∈ D
hxy : x ≤ y
⊢ f y ≤ f x
state_after: no goals
tactic: simpa only [zero_mul, sub_nonpos] using
    hD.image_sub_le_mul_sub_of_deriv_le hf hf' hf'_nonpos x hx y hy hxy
Theorem: lowerCentralSeries_length_eq_nilpotencyClass
File: Mathlib/GroupTheory/Nilpotent.lean

Proof steps:
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Group.nilpotencyClass G
state_after: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Nat.find ⋯
tactic: rw [← least_descending_central_series_length_eq_nilpotencyClass]
state_before: G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ Nat.find ⋯ = Nat.find ⋯
state_after: case refine_1
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), (∃ H, IsDescendingCentralSeries H ∧ H n = ⊥) → lowerCentralSeries G n = ⊥

case refine_2
G : Type u_1
inst✝¹ : Group G
H : Subgroup G
inst✝ : H.Normal
hG : Group.IsNilpotent G
⊢ ∀ (n : ℕ), lowerCentralSeries G n = ⊥ → ∃ H, IsDescendingCentralSeries H ∧ H n = ⊥
tactic: refine le_antisymm (Nat.find_mono ?_) (Nat.find_mono ?_)
Theorem: Finsupp.toFreeAbelianGroup_comp_toFinsupp
File: Mathlib/GroupTheory/FreeAbelianGroupFinsupp.lean

Proof steps:
state_before: X : Type u_1
⊢ toFreeAbelianGroup.comp toFinsupp = AddMonoidHom.id (FreeAbelianGroup X)
state_after: case H
X : Type u_1
x✝ : X
⊢ (toFreeAbelianGroup.comp toFinsupp) (of x✝) = (AddMonoidHom.id (FreeAbelianGroup X)) (of x✝)
tactic: ext
state_before: case H
X : Type u_1
x✝ : X
⊢ (toFreeAbelianGroup.comp toFinsupp) (of x✝) = (AddMonoidHom.id (FreeAbelianGroup X)) (of x✝)
state_after: no goals
tactic: rw [toFreeAbelianGroup, toFinsupp, AddMonoidHom.comp_apply, lift.of,
    liftAddHom_apply_single, AddMonoidHom.flip_apply, smulAddHom_apply, one_smul,
    AddMonoidHom.id_apply]
Theorem: FirstOrder.Language.withConstants_funMap_sum_inr
File: Mathlib/ModelTheory/LanguageMap.lean

Proof steps:
state_before: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) x = ↑(L.con a)
state_after: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) default = ↑(L.con a)
tactic: rw [Unique.eq_default x]
state_before: L : Language
L' : Language
M : Type w
inst✝¹ : L.Structure M
α : Type u_1
inst✝ : (constantsOn α).Structure M
a : α
x : Fin 0 → M
⊢ funMap (Sum.inr a) default = ↑(L.con a)
state_after: no goals
tactic: exact (LHom.sumInr : constantsOn α →ᴸ L.sum _).map_onFunction _ _
Theorem: ZFSet.toSet_insert
File: Mathlib/SetTheory/ZFC/Basic.lean

Proof steps:
state_before: x y : ZFSet
⊢ (insert x y).toSet = insert x y.toSet
state_after: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (insert x y).toSet ↔ x✝ ∈ insert x y.toSet
tactic: ext
state_before: case h
x y x✝ : ZFSet
⊢ x✝ ∈ (insert x y).toSet ↔ x✝ ∈ insert x y.toSet
state_after: no goals
tactic: simp
Theorem: List.sublists_perm_sublists'
File: Mathlib/Data/List/Sublists.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ l.sublists ~ l.sublists'
state_after: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map (map l.get) (finRange l.length).sublists ~ map (map l.get) (finRange l.length).sublists'
tactic: rw [← finRange_map_get l, sublists_map, sublists'_map]
state_before: α : Type u
β : Type v
γ : Type w
l : List α
⊢ map (map l.get) (finRange l.length).sublists ~ map (map l.get) (finRange l.length).sublists'
state_after: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists ~ (finRange l.length).sublists'
tactic: apply Perm.map
state_before: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists ~ (finRange l.length).sublists'
state_after: case p
α : Type u
β : Type v
γ : Type w
l : List α
⊢ ∀ (a : List (Fin l.length)), a ∈ (finRange l.length).sublists ↔ a ∈ (finRange l.length).sublists'

α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists.Nodup

α : Type u
β : Type v
γ : Type w
l : List α
⊢ (finRange l.length).sublists'.Nodup
tactic: apply (perm_ext_iff_of_nodup _ _).mpr
Theorem: Nat.primeFactorsList_chain
File: Mathlib/Data/Nat/Factors.lean

Proof steps:
state_before: n : ℕ
⊢ ∀ {a : ℕ}, (∀ (p : ℕ), Prime p → p ∣ n → a ≤ p) → List.Chain (fun x x_1 => x ≤ x_1) a n.primeFactorsList
state_after: no goals
tactic: match n with
  | 0 => simp
  | 1 => simp
  | k + 2 =>
      intro a h
      let m := minFac (k + 2)
      have : (k + 2) / m < (k + 2) := factors_lemma
      rw [primeFactorsList]
      refine List.Chain.cons ((le_minFac.2 h).resolve_left (by simp)) (primeFactorsList_chain ?_)
      exact fun p pp d => minFac_le_of_dvd pp.two_le (d.trans <| div_dvd_of_dvd <| minFac_dvd _)
Theorem: OrderEmbedding.coe_birkhoffFinset
File: Mathlib/Order/Birkhoff.lean

Proof steps:
state_before: α : Type u_1
inst✝³ : DistribLattice α
inst✝² : OrderBot α
inst✝¹ : Fintype α
inst✝ : DecidablePred SupIrred
a : α
⊢ ↑(birkhoffFinset a) = birkhoffSet a
state_after: no goals
tactic: classical
  -- TODO: This should be a single `simp` call but `simp` refuses to use
  -- `OrderIso.coe_toOrderEmbedding` and `Fintype.coe_finsetOrderIsoSet_symm`
  simp [birkhoffFinset]
  rw [OrderIso.coe_toOrderEmbedding, Fintype.coe_finsetOrderIsoSet_symm]
  simp
Theorem: AlgebraicGeometry.StructureSheaf.const_mul_cancel'
File: Mathlib/AlgebraicGeometry/StructureSheaf.lean

Proof steps:
state_before: R : Type u
inst✝ : CommRing R
f g₁ g₂ : R
U : Opens ↑(PrimeSpectrum.Top R)
hu₁ : ∀ x ∈ U, g₁ ∈ x.asIdeal.primeCompl
hu₂ : ∀ x ∈ U, g₂ ∈ x.asIdeal.primeCompl
⊢ const R g₁ g₂ U hu₂ * const R f g₁ U hu₁ = const R f g₂ U hu₂
state_after: no goals
tactic: rw [mul_comm, const_mul_cancel]
Theorem: Turing.TM2.step_supports
File: Mathlib/Computability/TuringMachine.lean

Proof steps:
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
c' : Cfg₂
h₁ : c' ∈ step M { l := some l₁, var := v, stk := T }
h₂ : { l := some l₁, var := v, stk := T }.l ∈ Finset.insertNone S
⊢ c'.l ∈ Finset.insertNone S
state_after: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
c' : Cfg₂
h₁ : c' ∈ step M { l := some l₁, var := v, stk := T }
h₂ : SupportsStmt S (M l₁)
⊢ c'.l ∈ Finset.insertNone S
tactic: replace h₂ := ss.2 _ (Finset.some_mem_insertNone.1 h₂)
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
c' : Cfg₂
h₁ : c' ∈ step M { l := some l₁, var := v, stk := T }
h₂ : SupportsStmt S (M l₁)
⊢ c'.l ∈ Finset.insertNone S
state_after: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
c' : Cfg₂
h₂ : SupportsStmt S (M l₁)
h₁ : stepAux (M l₁) v T = c'
⊢ c'.l ∈ Finset.insertNone S
tactic: simp only [step, Option.mem_def, Option.some.injEq] at h₁
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
c' : Cfg₂
h₂ : SupportsStmt S (M l₁)
h₁ : stepAux (M l₁) v T = c'
⊢ c'.l ∈ Finset.insertNone S
state_after: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
h₂ : SupportsStmt S (M l₁)
⊢ (stepAux (M l₁) v T).l ∈ Finset.insertNone S
tactic: subst c'
state_before: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
h₂ : SupportsStmt S (M l₁)
⊢ (stepAux (M l₁) v T).l ∈ Finset.insertNone S
state_after: K : Type u_1
inst✝¹ : DecidableEq K
Γ : K → Type u_2
Λ : Type u_3
σ : Type u_4
inst✝ : Inhabited Λ
M : Λ → Stmt₂
S : Finset Λ
ss : Supports M S
l₁ : Λ
v : σ
T : (k : K) → List (Γ k)
⊢ SupportsStmt S (M l₁) → (stepAux (M l₁) v T).l ∈ Finset.insertNone S
tactic: revert h₂
Theorem: Polynomial.opRingEquiv_symm_C_mul_X_pow
File: Mathlib/RingTheory/Polynomial/Opposites.lean

Proof steps:
state_before: R : Type u_1
inst✝ : Semiring R
r : Rᵐᵒᵖ
n : ℕ
⊢ (opRingEquiv R).symm (C r * X ^ n) = op (C (unop r) * X ^ n)
state_after: no goals
tactic: rw [C_mul_X_pow_eq_monomial, opRingEquiv_symm_monomial, C_mul_X_pow_eq_monomial]
Theorem: CategoryTheory.BraidedCategory.yang_baxter'
File: Mathlib/CategoryTheory/Monoidal/Braided/Basic.lean

Proof steps:
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X =
    𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)
state_after: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    ((α_ X Y Z).inv ≫
        𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom
tactic: rw [← cancel_epi (α_ X Y Z).inv, ← cancel_mono (α_ Z Y X).hom]
state_before: C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    ((α_ X Y Z).inv ≫
        𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom
state_after: case h.e'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    (α_ X Y Z).inv ≫
      (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom

case h.e'_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ 𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom =
    X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom
tactic: convert yang_baxter X Y Z using 1
state_before: case h.e'_2
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ (β_ X Y).hom ▷ Z ⊗≫ Y ◁ (β_ X Z).hom ⊗≫ (β_ Y Z).hom ▷ X) ≫ (α_ Z Y X).hom =
    (α_ X Y Z).inv ≫
      (β_ X Y).hom ▷ Z ≫ (α_ Y X Z).hom ≫ Y ◁ (β_ X Z).hom ≫ (α_ Y Z X).inv ≫ (β_ Y Z).hom ▷ X ≫ (α_ Z Y X).hom

case h.e'_3
C : Type u
inst✝² : Category.{v, u} C
inst✝¹ : MonoidalCategory C
inst✝ : BraidedCategory C
X Y Z : C
⊢ ((α_ X Y Z).inv ≫ 𝟙 ((X ⊗ Y) ⊗ Z) ⊗≫ (X ◁ (β_ Y Z).hom ⊗≫ (β_ X Z).hom ▷ Y ⊗≫ Z ◁ (β_ X Y).hom) ⊗≫ 𝟙 ((Z ⊗ Y) ⊗ X)) ≫
      (α_ Z Y X).hom =
    X ◁ (β_ Y Z).hom ≫ (α_ X Z Y).inv ≫ (β_ X Z).hom ▷ Y ≫ (α_ Z X Y).hom ≫ Z ◁ (β_ X Y).hom
state_after: no goals
tactic: all_goals coherence
Theorem: KaehlerDifferential.mapBaseChange_tmul
File: Mathlib/RingTheory/Kaehler/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x : B
y : Ω[A⁄R]
⊢ (mapBaseChange R A B) (x ⊗ₜ[A] y) = x • (map R R A B) y
state_after: R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x : B
y : Ω[A⁄R]
⊢ x • (mapBaseChange R A B) (1 ⊗ₜ[A] y) = x • (map R R A B) y
tactic: conv_lhs => rw [← mul_one x, ← smul_eq_mul, ← TensorProduct.smul_tmul', LinearMap.map_smul]
state_before: R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x : B
y : Ω[A⁄R]
⊢ x • (mapBaseChange R A B) (1 ⊗ₜ[A] y) = x • (map R R A B) y
state_after: case e_a
R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x : B
y : Ω[A⁄R]
⊢ (mapBaseChange R A B) (1 ⊗ₜ[A] y) = (map R R A B) y
tactic: congr 1
state_before: case e_a
R : Type u
S : Type v
inst✝¹⁵ : CommRing R
inst✝¹⁴ : CommRing S
inst✝¹³ : Algebra R S
M : Type u_1
inst✝¹² : AddCommGroup M
inst✝¹¹ : Module R M
inst✝¹⁰ : Module S M
inst✝⁹ : IsScalarTower R S M
A : Type u_2
B : Type u_3
inst✝⁸ : CommRing A
inst✝⁷ : CommRing B
inst✝⁶ : Algebra R A
inst✝⁵ : Algebra R B
inst✝⁴ : Algebra A B
inst✝³ : Algebra S B
inst✝² : IsScalarTower R A B
inst✝¹ : IsScalarTower R S B
inst✝ : SMulCommClass S A B
x : B
y : Ω[A⁄R]
⊢ (mapBaseChange R A B) (1 ⊗ₜ[A] y) = (map R R A B) y
state_after: no goals
tactic: exact IsBaseChange.lift_eq _ _ _