ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Real.list_prod_map_rpow
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: w x y z : ℝ
l : List ℝ
hl : ∀ x ∈ l, 0 ≤ x
r : ℝ
⊢ (List.map (fun x => x ^ r) l).prod = l.prod ^ r
state_after: case intro
w x y z r : ℝ
l : List ℝ≥0
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
tactic: lift l to List ℝ≥0 using hl
state_before: case intro
w x y z r : ℝ
l : List ℝ≥0
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
state_after: case intro
w x y z r : ℝ
l : List ℝ≥0
this : ↑(List.map (fun x => x ^ r) l).prod = ↑(l.prod ^ r)
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
tactic: have := congr_arg ((↑) : ℝ≥0 → ℝ) (NNReal.list_prod_map_rpow l r)
state_before: case intro
w x y z r : ℝ
l : List ℝ≥0
this : ↑(List.map (fun x => x ^ r) l).prod = ↑(l.prod ^ r)
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
state_after: case intro
w x y z r : ℝ
l : List ℝ≥0
this : (List.map toReal (List.map (fun x => x ^ r) l)).prod = (List.map toReal l).prod ^ r
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
tactic: push_cast at this
state_before: case intro
w x y z r : ℝ
l : List ℝ≥0
this : (List.map toReal (List.map (fun x => x ^ r) l)).prod = (List.map toReal l).prod ^ r
⊢ (List.map (fun x => x ^ r) (List.map toReal l)).prod = (List.map toReal l).prod ^ r
state_after: case intro
w x y z r : ℝ
l : List ℝ≥0
this : (List.map (toReal ∘ fun x => x ^ r) l).prod = (List.map toReal l).prod ^ r
⊢ (List.map ((fun x => x ^ r) ∘ toReal) l).prod = (List.map toReal l).prod ^ r
tactic: rw [List.map_map] at this ⊢
state_before: case intro
w x y z r : ℝ
l : List ℝ≥0
this : (List.map (toReal ∘ fun x => x ^ r) l).prod = (List.map toReal l).prod ^ r
⊢ (List.map ((fun x => x ^ r) ∘ toReal) l).prod = (List.map toReal l).prod ^ r
state_after: no goals
tactic: exact mod_cast this
Theorem: Metric.cobounded_eq_cocompact
File: Mathlib/Topology/MetricSpace/Bounded.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
⊢ cobounded α = cocompact α
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
a✝ : Nontrivial α
⊢ cobounded α = cocompact α
tactic: nontriviality α
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
a✝ : Nontrivial α
⊢ cobounded α = cocompact α
state_after: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ cobounded α = cocompact α
tactic: inhabit α
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝¹ : PseudoMetricSpace α
inst✝ : ProperSpace α
a✝ : Nontrivial α
inhabited_h : Inhabited α
⊢ cobounded α = cocompact α
state_after: no goals
tactic: exact cobounded_le_cocompact.antisymm <| (hasBasis_cobounded_compl_closedBall default).ge_iff.2
    fun _ _ ↦ (isCompact_closedBall _ _).compl_mem_cocompact
Theorem: FirstOrder.Language.DirectLimit.lift_of
File: Mathlib/ModelTheory/DirectLimit.lean

Proof steps:
state_before: L : Language
ι : Type v
inst✝⁵ : Preorder ι
G : ι → Type w
inst✝⁴ : (i : ι) → L.Structure (G i)
f : (i j : ι) → i ≤ j → G i ↪[L] G j
inst✝³ : IsDirected ι fun x x_1 => x ≤ x_1
inst✝² : DirectedSystem G fun i j h => ⇑(f i j h)
inst✝¹ : Nonempty ι
P : Type u₁
inst✝ : L.Structure P
g : (i : ι) → G i ↪[L] P
Hg : ∀ (i j : ι) (hij : i ≤ j) (x : G i), (g j) ((f i j hij) x) = (g i) x
i : ι
x : G i
⊢ (lift L ι G f g Hg) ((of L ι G f i) x) = (g i) x
state_after: no goals
tactic: simp
Theorem: Pell.isPell_pellZd
File: Mathlib/NumberTheory/PellMatiyasevic.lean

Proof steps:
state_before: a : ℕ
a1 : 1 < a
n : ℕ
⊢ IsPell (pellZd a1 (n + 1))
state_after: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 (n + 1))
tactic: let o := isPell_one a1
state_before: a : ℕ
a1 : 1 < a
n : ℕ
o : IsPell { re := ↑a, im := 1 } := isPell_one a1
⊢ IsPell (pellZd a1 (n + 1))
state_after: no goals
tactic: simpa using Pell.isPell_mul (isPell_pellZd n) o
Theorem: Nat.digits_eq_cons_digits_div
File: Mathlib/Data/Nat/Digits.lean

Proof steps:
state_before: n✝ b n : ℕ
h : 1 < b
w : n ≠ 0
⊢ b.digits n = n % b :: b.digits (n / b)
state_after: case zero
n✝ n : ℕ
w : n ≠ 0
h : 1 < 0
⊢ digits 0 n = n % 0 :: digits 0 (n / 0)

case succ.zero
n✝ n : ℕ
w : n ≠ 0
h : 1 < 0 + 1
⊢ (0 + 1).digits n = n % (0 + 1) :: (0 + 1).digits (n / (0 + 1))

case succ.succ
n✝ n : ℕ
w : n ≠ 0
b : ℕ
h : 1 < b + 1 + 1
⊢ (b + 1 + 1).digits n = n % (b + 1 + 1) :: (b + 1 + 1).digits (n / (b + 1 + 1))
tactic: rcases b with (_ | _ | b)
state_before: case succ.succ
n✝ n : ℕ
w : n ≠ 0
b : ℕ
h : 1 < b + 1 + 1
⊢ (b + 1 + 1).digits n = n % (b + 1 + 1) :: (b + 1 + 1).digits (n / (b + 1 + 1))
state_after: case succ.succ.zero
n b : ℕ
h : 1 < b + 1 + 1
w : 0 ≠ 0
⊢ (b + 1 + 1).digits 0 = 0 % (b + 1 + 1) :: (b + 1 + 1).digits (0 / (b + 1 + 1))

case succ.succ.succ
n✝ b : ℕ
h : 1 < b + 1 + 1
n : ℕ
w : n + 1 ≠ 0
⊢ (b + 1 + 1).digits (n + 1) = (n + 1) % (b + 1 + 1) :: (b + 1 + 1).digits ((n + 1) / (b + 1 + 1))
tactic: rcases n with (_ | n)
Theorem: AlgebraicGeometry.PresheafedSpace.IsOpenImmersion.pullback_cone_of_left_condition
File: Mathlib/Geometry/RingedSpace/OpenImmersion.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
⊢ pullbackConeOfLeftFst f g ≫ f = Y.ofRestrict ⋯ ≫ g
state_after: case refine_1
C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
⊢ (pullbackConeOfLeftFst f g ≫ f).base = (Y.ofRestrict ⋯ ≫ g).base

case refine_2
C : Type u
inst✝ : Category.{v, u} C
X Y Z : PresheafedSpace C
f : X ⟶ Z
hf : IsOpenImmersion f
g : Y ⟶ Z
U : (Opens ↑↑Z)ᵒᵖ
⊢ ((pullbackConeOfLeftFst f g ≫ f).c ≫ whiskerRight (eqToHom ⋯) (Y.restrict ⋯).presheaf).app U =
    (Y.ofRestrict ⋯ ≫ g).c.app U
tactic: refine PresheafedSpace.Hom.ext _ _ ?_ <| NatTrans.ext _ _ <| funext fun U => ?_
Theorem: Ring.inverse_unit
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
u : M₀ˣ
⊢ inverse ↑u = ↑u⁻¹
state_after: no goals
tactic: rw [inverse, dif_pos u.isUnit, IsUnit.unit_of_val_units]
Theorem: FreeLieAlgebra.universalEnvelopingEquivFreeAlgebra_apply
File: Mathlib/Algebra/Lie/Free.lean

Proof steps:
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
      ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)) =
    AlgHom.id R (FreeAlgebra R X)
state_after: case w.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ (⇑(((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
            ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R))) ∘
        FreeAlgebra.ι R)
      x✝ =
    (⇑(AlgHom.id R (FreeAlgebra R X)) ∘ FreeAlgebra.ι R) x✝
tactic: ext
state_before: case w.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ (⇑(((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))).comp
            ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R))) ∘
        FreeAlgebra.ι R)
      x✝ =
    (⇑(AlgHom.id R (FreeAlgebra R X)) ∘ FreeAlgebra.ι R) x✝
state_after: no goals
tactic: simp
state_before: R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
⊢ ((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
      ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R))) =
    AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))
state_after: case h.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ ((((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
              ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R)))).toLieHom.comp
        (UniversalEnvelopingAlgebra.ι R))
      (of R x✝) =
    ((AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))).toLieHom.comp (UniversalEnvelopingAlgebra.ι R))
      (of R x✝)
tactic: ext
state_before: case h.h
R : Type u
X : Type v
inst✝² : CommRing R
L : Type w
inst✝¹ : LieRing L
inst✝ : LieAlgebra R L
x✝ : X
⊢ ((((FreeAlgebra.lift R) (⇑(UniversalEnvelopingAlgebra.ι R) ∘ of R)).comp
              ((UniversalEnvelopingAlgebra.lift R) ((lift R) (FreeAlgebra.ι R)))).toLieHom.comp
        (UniversalEnvelopingAlgebra.ι R))
      (of R x✝) =
    ((AlgHom.id R (UniversalEnvelopingAlgebra R (FreeLieAlgebra R X))).toLieHom.comp (UniversalEnvelopingAlgebra.ι R))
      (of R x✝)
state_after: no goals
tactic: simp
Theorem: lt_of_mul_lt_mul_of_le₀
File: Mathlib/Algebra/Order/GroupWithZero/Canonical.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
hh : c ≤ a
⊢ b < d
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
hh : c ≤ a
ha : a ≠ 0
⊢ b < d
tactic: have ha : a ≠ 0 := ne_of_gt (lt_of_lt_of_le hc hh)
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
hh : c ≤ a
ha : a ≠ 0
⊢ b < d
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
⊢ b < d
tactic: simp_rw [← inv_le_inv₀ ha (ne_of_gt hc)] at hh
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
⊢ b < d
state_after: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
this : a⁻¹ * (a * b) < c⁻¹ * (c * d)
⊢ b < d
tactic: have := mul_lt_mul_of_lt_of_le₀ hh (inv_ne_zero (ne_of_gt hc)) h
state_before: α : Type u_1
inst✝ : LinearOrderedCommGroupWithZero α
a b c d : α
m n : ℕ
h : a * b < c * d
hc : 0 < c
ha : a ≠ 0
hh : a⁻¹ ≤ c⁻¹
this : a⁻¹ * (a * b) < c⁻¹ * (c * d)
⊢ b < d
state_after: no goals
tactic: simpa [inv_mul_cancel_left₀ ha, inv_mul_cancel_left₀ (ne_of_gt hc)] using this
Theorem: Polynomial.card_rootSet_eq_natDegree
File: Mathlib/FieldTheory/Separable.lean

Proof steps:
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : p.Separable
hsplit : Splits (algebraMap F K) p
⊢ Fintype.card ↑(p.rootSet K) = p.natDegree
state_after: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : p.Separable
hsplit : Splits (algebraMap F K) p
⊢ (p.aroots K).toFinset.card = p.natDegree
tactic: simp_rw [rootSet_def, Finset.coe_sort_coe, Fintype.card_coe]
state_before: F : Type u
inst✝² : Field F
K : Type v
inst✝¹ : Field K
inst✝ : Algebra F K
p : F[X]
hsep : p.Separable
hsplit : Splits (algebraMap F K) p
⊢ (p.aroots K).toFinset.card = p.natDegree
state_after: no goals
tactic: rw [Multiset.toFinset_card_of_nodup (nodup_roots hsep.map), ← natDegree_eq_card_roots hsplit]
Theorem: Int.cast_neg
File: Mathlib/Data/Int/Cast/Basic.lean

Proof steps:
state_before: R : Type u
inst✝ : AddGroupWithOne R
⊢ ↑(-↑0) = -↑↑0
state_after: no goals
tactic: erw [cast_zero, neg_zero]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(-↑(n + 1)) = -↑↑(n + 1)
state_after: no goals
tactic: erw [cast_natCast, cast_negSucc]
state_before: R : Type u
inst✝ : AddGroupWithOne R
n : ℕ
⊢ ↑(- -[n+1]) = -↑-[n+1]
state_after: no goals
tactic: erw [cast_natCast, cast_negSucc, neg_neg]
Theorem: Ring.inverse_mul_cancel_right
File: Mathlib/Algebra/GroupWithZero/Units/Basic.lean

Proof steps:
state_before: α : Type u_1
M₀ : Type u_2
G₀ : Type u_3
M₀' : Type u_4
G₀' : Type u_5
F : Type u_6
F' : Type u_7
inst✝ : MonoidWithZero M₀
x y : M₀
h : IsUnit x
⊢ y * inverse x * x = y
state_after: no goals
tactic: rw [mul_assoc, inverse_mul_cancel x h, mul_one]
Theorem: CategoryTheory.DifferentialObject.eqToHom_f'
File: Mathlib/Algebra/Homology/DifferentialObject.lean

Proof steps:
state_before: β : Type u_1
inst✝² : AddCommGroup β
b : β
V : Type u_2
inst✝¹ : Category.{u_3, u_2} V
inst✝ : HasZeroMorphisms V
X✝ X Y : DifferentialObject ℤ (GradedObjectWithShift b V)
f : X ⟶ Y
x y : β
h : x = y
⊢ X.objEqToHom h ≫ f.f y = f.f x ≫ Y.objEqToHom h
state_after: case refl
β : Type u_1
inst✝² : AddCommGroup β
b : β
V : Type u_2
inst✝¹ : Category.{u_3, u_2} V
inst✝ : HasZeroMorphisms V
X✝ X Y : DifferentialObject ℤ (GradedObjectWithShift b V)
f : X ⟶ Y
x : β
⊢ X.objEqToHom ⋯ ≫ f.f x = f.f x ≫ Y.objEqToHom ⋯
tactic: cases h
state_before: case refl
β : Type u_1
inst✝² : AddCommGroup β
b : β
V : Type u_2
inst✝¹ : Category.{u_3, u_2} V
inst✝ : HasZeroMorphisms V
X✝ X Y : DifferentialObject ℤ (GradedObjectWithShift b V)
f : X ⟶ Y
x : β
⊢ X.objEqToHom ⋯ ≫ f.f x = f.f x ≫ Y.objEqToHom ⋯
state_after: no goals
tactic: simp
Theorem: AlgebraicGeometry.RingedSpace.mem_zeroLocus_iff
File: Mathlib/Geometry/RingedSpace/Basic.lean

Proof steps:
state_before: X : RingedSpace
U : Opens ↑↑X.toPresheafedSpace
s : Set ↑(X.presheaf.obj (op U))
x : ↑↑X.toPresheafedSpace
⊢ x ∈ X.zeroLocus s ↔ ∀ f ∈ s, x ∉ X.basicOpen f
state_after: no goals
tactic: simp [zeroLocus]
Theorem: List.prod_isUnit_iff
File: Mathlib/Algebra/BigOperators/Group/List.lean

Proof steps:
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
⊢ IsUnit L.prod ↔ ∀ m ∈ L, IsUnit m
state_after: ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m
tactic: refine ⟨fun h => ?_, prod_isUnit⟩
state_before: ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
L : List α
h : IsUnit L.prod
⊢ ∀ m ∈ L, IsUnit m
state_after: case nil
ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
h : IsUnit [].prod
⊢ ∀ m ∈ [], IsUnit m

case cons
ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
tactic: induction' L with m L ih
state_before: case cons
ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit (m :: L).prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: case cons
ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
tactic: rw [prod_cons, IsUnit.mul_iff] at h
state_before: case cons
ι : Type u_1
α✝ : Type u_2
β : Type u_3
M : Type u_4
N : Type u_5
P : Type u_6
G : Type u_7
inst✝³ : Monoid M
inst✝² : Monoid N
inst✝¹ : Monoid P
l l₁ l₂ : List M
a : M
α : Type u_8
inst✝ : CommMonoid α
m : α
L : List α
ih : IsUnit L.prod → ∀ m ∈ L, IsUnit m
h : IsUnit m ∧ IsUnit L.prod
⊢ ∀ m_1 ∈ m :: L, IsUnit m_1
state_after: no goals
tactic: exact fun m' h' => Or.elim (eq_or_mem_of_mem_cons h') (fun H => H.substr h.1) fun H => ih h.2 _ H
Theorem: Mathlib.Tactic.Ring.div_congr
File: Mathlib/Tactic/Ring/Basic.lean

Proof steps:
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a✝ a'✝ a₁ a₂ a₃ b✝ b'✝ b₁ b₂ b₃ c✝ c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a a' b b' c : R
x✝² : a = a'
x✝¹ : b = b'
x✝ : a' / b' = c
⊢ a / b = c
state_after: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b'✝ b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a' b' : R
⊢ a' / b' = a' / b'
tactic: subst_vars
state_before: u✝ : Lean.Level
arg : Q(Type u✝)
sα✝ : Q(CommSemiring «$arg»)
u : Lean.Level
α : Q(Type u)
sα : Q(CommSemiring «$α»)
R✝ : Type u_1
inst✝¹ : CommSemiring R✝
a a'✝ a₁ a₂ a₃ b b'✝ b₁ b₂ b₃ c c₁ c₂ : R✝
R : Type u_2
inst✝ : DivisionRing R
a' b' : R
⊢ a' / b' = a' / b'
state_after: no goals
tactic: rfl
Theorem: EuclideanGeometry.angle_eq_pi_div_two_of_oangle_eq_neg_pi_div_two
File: Mathlib/Geometry/Euclidean/Angle/Oriented/Affine.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
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ∠ p₁ p₂ p₃ = π / 2
state_after: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0
tactic: rw [angle, ← InnerProductGeometry.inner_eq_zero_iff_angle_eq_pi_div_two]
state_before: V : Type u_1
P : Type u_2
inst✝⁴ : NormedAddCommGroup V
inst✝³ : InnerProductSpace ℝ V
inst✝² : MetricSpace P
inst✝¹ : NormedAddTorsor V P
hd2 : Fact (finrank ℝ V = 2)
inst✝ : Module.Oriented ℝ V (Fin 2)
p₁ p₂ p₃ : P
h : ∡ p₁ p₂ p₃ = ↑(-π / 2)
⊢ ⟪p₁ -ᵥ p₂, p₃ -ᵥ p₂⟫_ℝ = 0
state_after: no goals
tactic: exact o.inner_eq_zero_of_oangle_eq_neg_pi_div_two h
Theorem: CauSeq.Completion.mul_inv_cancel
File: Mathlib/Algebra/Order/CauSeq/Completion.lean

Proof steps:
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ⟦f⟧ ≠ 0
⊢ ⟦f⟧ * (⟦f⟧)⁻¹ = 1
state_after: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬f.LimZero
⊢ ⟦f⟧ * (⟦f⟧)⁻¹ = 1
tactic: simp only [mk_eq_mk, ne_eq, mk_eq_zero] at hf
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬f.LimZero
⊢ ⟦f⟧ * (⟦f⟧)⁻¹ = 1
state_after: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬f.LimZero
⊢ mk (f * f.inv ⋯) = 1
tactic: simp only [mk_eq_mk, hf, not_false_eq_true, inv_mk, mk_mul]
state_before: α : Type u_1
inst✝² : LinearOrderedField α
β : Type u_2
inst✝¹ : DivisionRing β
abv : β → α
inst✝ : IsAbsoluteValue abv
x : Cauchy abv
f : CauSeq β abv
hf : ¬f.LimZero
⊢ mk (f * f.inv ⋯) = 1
state_after: no goals
tactic: exact Quotient.sound (CauSeq.mul_inv_cancel hf)
Theorem: SimpleGraph.CliqueFree.comap
File: Mathlib/Combinatorics/SimpleGraph/Clique.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
G H✝ : SimpleGraph α
m n : ℕ
s : Finset α
H : SimpleGraph β
f : H ↪g G
⊢ G.CliqueFree n → H.CliqueFree n
state_after: α : Type u_1
β : Type u_2
G H✝ : SimpleGraph α
m n : ℕ
s : Finset α
H : SimpleGraph β
f : H ↪g G
h : G.CliqueFree n
⊢ H.CliqueFree n
tactic: intro h
state_before: α : Type u_1
β : Type u_2
G H✝ : SimpleGraph α
m n : ℕ
s : Finset α
H : SimpleGraph β
f : H ↪g G
h : G.CliqueFree n
⊢ H.CliqueFree n
state_after: α : Type u_1
β : Type u_2
G H✝ : SimpleGraph α
m n : ℕ
s : Finset α
H : SimpleGraph β
f : H ↪g G
h : ¬H.CliqueFree n
⊢ ¬G.CliqueFree n
tactic: contrapose h
state_before: α : Type u_1
β : Type u_2
G H✝ : SimpleGraph α
m n : ℕ
s : Finset α
H : SimpleGraph β
f : H ↪g G
h : ¬H.CliqueFree n
⊢ ¬G.CliqueFree n
state_after: no goals
tactic: exact not_cliqueFree_of_top_embedding <| f.comp (topEmbeddingOfNotCliqueFree h)
Theorem: PrimeSpectrum.vanishingIdeal_strict_anti_mono_iff
File: Mathlib/AlgebraicGeometry/PrimeSpectrum/Basic.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommSemiring R
inst✝ : CommSemiring S
s t : Set (PrimeSpectrum R)
hs : IsClosed s
ht : IsClosed t
⊢ s ⊂ t ↔ vanishingIdeal t < vanishingIdeal s
state_after: no goals
tactic: rw [Set.ssubset_def, vanishingIdeal_anti_mono_iff hs, vanishingIdeal_anti_mono_iff ht,
    lt_iff_le_not_le]
Theorem: WittVector.bind₁_frobeniusPolyRat_wittPolynomial
File: Mathlib/RingTheory/WittVector/Frobenius.lean

Proof steps:
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (bind₁ (frobeniusPolyRat p)) (wittPolynomial p ℚ n) = wittPolynomial p ℚ (n + 1)
state_after: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (bind₁ fun n => (bind₁ (wittPolynomial p ℚ ∘ fun n => n + 1)) (xInTermsOfW p ℚ n)) (wittPolynomial p ℚ n) =
    wittPolynomial p ℚ (n + 1)
tactic: delta frobeniusPolyRat
state_before: p : ℕ
R : Type u_1
S : Type u_2
hp : Fact (Nat.Prime p)
inst✝¹ : CommRing R
inst✝ : CommRing S
n : ℕ
⊢ (bind₁ fun n => (bind₁ (wittPolynomial p ℚ ∘ fun n => n + 1)) (xInTermsOfW p ℚ n)) (wittPolynomial p ℚ n) =
    wittPolynomial p ℚ (n + 1)
state_after: no goals
tactic: rw [← bind₁_bind₁, bind₁_xInTermsOfW_wittPolynomial, bind₁_X_right, Function.comp_apply]
Theorem: ProbabilityTheory.iCondIndepSets_singleton_iff
File: Mathlib/Probability/Independence/Conditional.lean

Proof steps:
state_before: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
s : ι → Set Ω
hπ : ∀ (i : ι), MeasurableSet (s i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ iCondIndepSets m' hm' (fun i => {s i}) μ ↔
    ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']
state_after: Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
s : ι → Set Ω
hπ : ∀ (i : ι), MeasurableSet (s i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ (∀ (s_1 : Finset ι) {f : ι → Set Ω},
      (∀ i ∈ s_1, f i ∈ {s i}) →
        μ[(⋂ i ∈ s_1, f i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ s_1, μ[(f i).indicator fun ω => 1|m']) ↔
    ∀ (S : Finset ι), μ[(⋂ i ∈ S, s i).indicator fun ω => 1|m'] =ᶠ[ae μ] ∏ i ∈ S, μ[(s i).indicator fun ω => 1|m']

case hπ
Ω : Type u_1
ι : Type u_2
m' mΩ : MeasurableSpace Ω
inst✝² : StandardBorelSpace Ω
inst✝¹ : Nonempty Ω
hm' : m' ≤ mΩ
s : ι → Set Ω
hπ : ∀ (i : ι), MeasurableSet (s i)
μ : Measure Ω
inst✝ : IsFiniteMeasure μ
⊢ ∀ (i : ι), ∀ s_1 ∈ {s i}, MeasurableSet s_1
tactic: rw [iCondIndepSets_iff]
Theorem: MeasureTheory.OuterMeasure.le_add_caratheodory
File: Mathlib/MeasureTheory/OuterMeasure/Caratheodory.lean

Proof steps:
state_before: α : Type u_1
m₁ m₂ : OuterMeasure α
s : Set α
x✝ : MeasurableSet s
t : Set α
hs₁ : s ∈ (fun m => {t | MeasurableSet t}) m₁.caratheodory
hs₂ : s ∈ (fun m => {t | MeasurableSet t}) m₂.caratheodory
⊢ (m₁ + m₂) t = (m₁ + m₂) (t ∩ s) + (m₁ + m₂) (t \ s)
state_after: no goals
tactic: simp [hs₁ t, hs₂ t, add_left_comm, add_assoc]