ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: polarCoord_source_ae_eq_univ
File: Mathlib/Analysis/SpecialFunctions/PolarCoord.lean

Proof steps:
state_before: ⊢ polarCoord.source =ᶠ[ae volume] univ
state_after: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ polarCoord.source =ᶠ[ae volume] univ
tactic: have A : polarCoord.sourceᶜ ⊆ LinearMap.ker (LinearMap.snd ℝ ℝ ℝ) := by
    intro x hx
    simp only [polarCoord_source, compl_union, mem_inter_iff, mem_compl_iff, mem_setOf_eq, not_lt,
      Classical.not_not] at hx
    exact hx.2
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
⊢ polarCoord.source =ᶠ[ae volume] univ
state_after: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ polarCoord.source =ᶠ[ae volume] univ
tactic: have B : volume (LinearMap.ker (LinearMap.snd ℝ ℝ ℝ) : Set (ℝ × ℝ)) = 0 := by
    apply Measure.addHaar_submodule
    rw [Ne, LinearMap.ker_eq_top]
    intro h
    have : (LinearMap.snd ℝ ℝ ℝ) (0, 1) = (0 : ℝ × ℝ →ₗ[ℝ] ℝ) (0, 1) := by rw [h]
    simp at this
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ polarCoord.source =ᶠ[ae volume] univ
state_after: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ volume polarCoord.sourceᶜ = 0
tactic: simp only [ae_eq_univ]
state_before: A : polarCoord.sourceᶜ ⊆ ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ))
B : volume ↑(LinearMap.ker (LinearMap.snd ℝ ℝ ℝ)) = 0
⊢ volume polarCoord.sourceᶜ = 0
state_after: no goals
tactic: exact le_antisymm ((measure_mono A).trans (le_of_eq B)) bot_le
Theorem: isCyclic_of_subgroup_isDomain
File: Mathlib/RingTheory/IntegralDomain.lean

Proof steps:
state_before: R : Type u_1
G : Type u_2
inst✝³ : CommRing R
inst✝² : IsDomain R
inst✝¹ : Group G
inst✝ : Finite G
f : G →* R
hf : Injective ⇑f
⊢ IsCyclic G
state_after: no goals
tactic: classical
    cases nonempty_fintype G
    apply isCyclic_of_card_pow_eq_one_le
    intro n hn
    exact le_trans (card_nthRoots_subgroup_units f hf hn 1) (card_nthRoots n (f 1))
Theorem: Int.ne_zero_of_gcd
File: Mathlib/Data/Int/GCD.lean

Proof steps:
state_before: x y : ℤ
hc : x.gcd y ≠ 0
⊢ x ≠ 0 ∨ y ≠ 0
state_after: x y : ℤ
hc : x = 0 ∧ y = 0
⊢ x.gcd y = 0
tactic: contrapose! hc
state_before: x y : ℤ
hc : x = 0 ∧ y = 0
⊢ x.gcd y = 0
state_after: no goals
tactic: rw [hc.left, hc.right, gcd_zero_right, natAbs_zero]
Theorem: isStronglyCoatomic_dual_iff_is_stronglyAtomic
File: Mathlib/Order/Atoms.lean

Proof steps:
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝¹ : PartialOrder α✝
α : Type u_4
a b : α
inst✝ : Preorder α
⊢ IsStronglyCoatomic αᵒᵈ ↔ IsStronglyAtomic α
state_after: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝¹ : PartialOrder α✝
α : Type u_4
a b : α
inst✝ : Preorder α
⊢ IsStronglyAtomic αᵒᵈᵒᵈ ↔ IsStronglyAtomic α
tactic: rw [← isStronglyAtomic_dual_iff_is_stronglyCoatomic]
state_before: ι : Sort u_1
α✝ : Type u_2
β : Type u_3
inst✝¹ : PartialOrder α✝
α : Type u_4
a b : α
inst✝ : Preorder α
⊢ IsStronglyAtomic αᵒᵈᵒᵈ ↔ IsStronglyAtomic α
state_after: no goals
tactic: rfl
Theorem: padicValRat.self_pow_inv
File: Mathlib/NumberTheory/Padics/PadicVal.lean

Proof steps:
state_before: p : ℕ
hp : Fact (Nat.Prime p)
r : ℕ
⊢ padicValRat p (↑p ^ r)⁻¹ = -↑r
state_after: no goals
tactic: rw [padicValRat.inv, neg_inj, padicValRat.pow (Nat.cast_ne_zero.mpr hp.elim.ne_zero),
      padicValRat.self hp.elim.one_lt, mul_one]
Theorem: DomAddAct.vadd_Lp_add
File: Mathlib/MeasureTheory/Function/LpSpace/DomAct/Basic.lean

Proof steps:
state_before: M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
⊢ ∀ (f g : ↥(Lp E p μ)), c • (f + g) = c • f + c • g
state_after: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩
tactic: rintro ⟨⟨⟩, _⟩ ⟨⟨⟩, _⟩
state_before: case mk.mk.mk.mk
M : Type u_1
N : Type u_2
α : Type u_3
E : Type u_4
inst✝⁶ : MeasurableSpace M
inst✝⁵ : MeasurableSpace N
inst✝⁴ : MeasurableSpace α
inst✝³ : NormedAddCommGroup E
μ : Measure α
p : ℝ≥0∞
inst✝² : SMul M α
inst✝¹ : SMulInvariantMeasure M α μ
inst✝ : MeasurableSMul M α
c : Mᵈᵐᵃ
val✝¹ : α →ₘ[μ] E
a✝¹ : { f // AEStronglyMeasurable f μ }
property✝¹ : Quot.mk Setoid.r a✝¹ ∈ Lp E p μ
val✝ : α →ₘ[μ] E
a✝ : { f // AEStronglyMeasurable f μ }
property✝ : Quot.mk Setoid.r a✝ ∈ Lp E p μ
⊢ c • (⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + ⟨Quot.mk Setoid.r a✝, property✝⟩) =
    c • ⟨Quot.mk Setoid.r a✝¹, property✝¹⟩ + c • ⟨Quot.mk Setoid.r a✝, property✝⟩
state_after: no goals
tactic: rfl
Theorem: ENNReal.rpow_eq_zero_iff
File: Mathlib/Analysis/SpecialFunctions/Pow/NNReal.lean

Proof steps:
state_before: x : ℝ≥0∞
y : ℝ
⊢ x ^ y = 0 ↔ x = 0 ∧ 0 < y ∨ x = ⊤ ∧ y < 0
state_after: case top
y : ℝ
⊢ ⊤ ^ y = 0 ↔ ⊤ = 0 ∧ 0 < y ∨ ⊤ = ⊤ ∧ y < 0

case coe
y : ℝ
x : ℝ≥0
⊢ ↑x ^ y = 0 ↔ ↑x = 0 ∧ 0 < y ∨ ↑x = ⊤ ∧ y < 0
tactic: cases' x with x
Theorem: PosNum.cast_inj
File: Mathlib/Data/Num/Lemmas.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : AddMonoidWithOne α
inst✝ : CharZero α
m n : PosNum
⊢ ↑m = ↑n ↔ m = n
state_after: no goals
tactic: rw [← cast_to_nat m, ← cast_to_nat n, Nat.cast_inj, to_nat_inj]
Theorem: Matroid.closure_iInter_eq_iInter_closure_of_iUnion_indep
File: Mathlib/Data/Matroid/Closure.lean

Proof steps:
state_before: ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hι : Nonempty ι
Is : ι → Set α
h : M.Indep (⋃ i, Is i)
⊢ M.closure (⋂ i, Is i) = ⋂ i, M.closure (Is i)
state_after: case h.e'_3
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hι : Nonempty ι
Is : ι → Set α
h : M.Indep (⋃ i, Is i)
⊢ ⋂ i, M.closure (Is i) = ⋂ J ∈ range Is, M.closure J
tactic: convert h.closure_sInter_eq_biInter_closure_of_forall_subset (range_nonempty Is)
    (by simp [subset_iUnion])
state_before: case h.e'_3
ι✝ : Type u_1
α : Type u_2
M : Matroid α
F X Y : Set α
e : α
ι : Sort u_3
I J B : Set α
f x y : α
hι : Nonempty ι
Is : ι → Set α
h : M.Indep (⋃ i, Is i)
⊢ ⋂ i, M.closure (Is i) = ⋂ J ∈ range Is, M.closure J
state_after: no goals
tactic: simp
Theorem: CategoryTheory.MonadIso.mk_hom_toNatTrans
File: Mathlib/CategoryTheory/Monad/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ N.η.app X ≫ f.inv.app X = M.η.app X
state_after: no goals
tactic: simp [← f_η]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ N.μ.app X ≫ f.inv.app X = (N.map (f.inv.app X) ≫ f.inv.app (M.obj X)) ≫ M.μ.app X
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ (N.μ.app X ≫ f.inv.app X) ≫ f.hom.app X = ((N.map (f.inv.app X) ≫ f.inv.app (M.obj X)) ≫ M.μ.app X) ≫ f.hom.app X
tactic: rw [← NatIso.cancel_natIso_hom_right f]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ (N.μ.app X ≫ f.inv.app X) ≫ f.hom.app X = ((N.map (f.inv.app X) ≫ f.inv.app (M.obj X)) ≫ M.μ.app X) ≫ f.hom.app X
state_after: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ N.μ.app X = N.map (𝟙 (N.obj X)) ≫ N.μ.app X
tactic: simp only [NatTrans.naturality, Iso.inv_hom_id_app, assoc, comp_id, f_μ,
          NatTrans.naturality_assoc, Iso.inv_hom_id_app_assoc, ← Functor.map_comp_assoc]
state_before: C : Type u₁
inst✝ : Category.{v₁, u₁} C
T : Monad C
G : Comonad C
M N : Monad C
f : M.toFunctor ≅ N.toFunctor
f_η : autoParam (∀ (X : C), M.η.app X ≫ f.hom.app X = N.η.app X) _auto✝
f_μ : autoParam (∀ (X : C), M.μ.app X ≫ f.hom.app X = (M.map (f.hom.app X) ≫ f.hom.app (N.obj X)) ≫ N.μ.app X) _auto✝
X : C
⊢ N.μ.app X = N.map (𝟙 (N.obj X)) ≫ N.μ.app X
state_after: no goals
tactic: simp
Theorem: Polynomial.iterate_derivative_X_sub_pow
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✝ : CommRing R
n k : ℕ
c : R
⊢ (⇑derivative)^[k] ((X - C c) ^ n) = n.descFactorial k • (X - C c) ^ (n - k)
state_after: no goals
tactic: rw [sub_eq_add_neg, ← C_neg, iterate_derivative_X_add_pow]
Theorem: Filter.HasBasis.uniformEmbedding_iff
File: Mathlib/Topology/UniformSpace/UniformEmbedding.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
inst✝² : UniformSpace α
inst✝¹ : UniformSpace β
inst✝ : UniformSpace γ
ι : Sort u_1
ι' : Sort u_2
p : ι → Prop
p' : ι' → Prop
s : ι → Set (α × α)
s' : ι' → Set (β × β)
h : (𝓤 α).HasBasis p s
h' : (𝓤 β).HasBasis p' s'
f : α → β
⊢ UniformEmbedding f ↔
    Injective f ∧ UniformContinuous f ∧ ∀ (j : ι), p j → ∃ i, p' i ∧ ∀ (x y : α), (f x, f y) ∈ s' i → (x, y) ∈ s j
state_after: no goals
tactic: simp only [h.uniformEmbedding_iff' h', h.uniformContinuous_iff h']
Theorem: mem_closedBall_iff_norm'
File: Mathlib/Analysis/Normed/Group/Basic.lean

Proof steps:
state_before: 𝓕 : Type u_1
𝕜 : Type u_2
α : Type u_3
ι : Type u_4
κ : Type u_5
E : Type u_6
F : Type u_7
G : Type u_8
inst✝² : SeminormedGroup E
inst✝¹ : SeminormedGroup F
inst✝ : SeminormedGroup G
s : Set E
a a₁ a₂ b b₁ b₂ : E
r r₁ r₂ : ℝ
⊢ b ∈ closedBall a r ↔ ‖a / b‖ ≤ r
state_after: no goals
tactic: rw [mem_closedBall', dist_eq_norm_div]
Theorem: Set.pred_ncard_le_ncard_diff_singleton
File: Mathlib/Data/Set/Card.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
⊢ s.ncard - 1 ≤ (s \ {a}).ncard
state_after: case inl
α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
hs : s.Finite
⊢ s.ncard - 1 ≤ (s \ {a}).ncard

case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
hs : s.Infinite
⊢ s.ncard - 1 ≤ (s \ {a}).ncard
tactic: cases' s.finite_or_infinite with hs hs
state_before: case inr
α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
hs : s.Infinite
⊢ s.ncard - 1 ≤ (s \ {a}).ncard
state_after: case h.e'_3
α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
hs : s.Infinite
⊢ s.ncard - 1 = 0
tactic: convert Nat.zero_le _
state_before: case h.e'_3
α : Type u_1
β : Type u_2
s✝ t s : Set α
a : α
hs : s.Infinite
⊢ s.ncard - 1 = 0
state_after: no goals
tactic: rw [hs.ncard]
Theorem: SimpleGraph.Walk.IsTrail.of_cons
File: Mathlib/Combinatorics/SimpleGraph/Path.lean

Proof steps:
state_before: V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
u✝ v✝ w✝ u v w : V
h : G.Adj u v
p : G.Walk v w
⊢ (cons h p).IsTrail → p.IsTrail
state_after: no goals
tactic: simp [isTrail_def]
Theorem: Metric.closedBall_eq_bInter_ball
File: Mathlib/Topology/MetricSpace/Pseudo/Defs.lean

Proof steps:
state_before: α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
⊢ closedBall x ε = ⋂ δ, ⋂ (_ : δ > ε), ball x δ
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
⊢ y ∈ closedBall x ε ↔ y ∈ ⋂ δ, ⋂ (_ : δ > ε), ball x δ
tactic: ext y
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
⊢ y ∈ closedBall x ε ↔ y ∈ ⋂ δ, ⋂ (_ : δ > ε), ball x δ
state_after: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
⊢ (∀ ⦃c : ℝ⦄, ε < c → dist y x < c) ↔ ∀ i > ε, y ∈ ball x i
tactic: rw [mem_closedBall, ← forall_lt_iff_le', mem_iInter₂]
state_before: case h
α : Type u
β : Type v
X : Type u_1
ι : Type u_2
inst✝ : PseudoMetricSpace α
x y✝ z : α
δ ε ε₁ ε₂ : ℝ
s : Set α
y : α
⊢ (∀ ⦃c : ℝ⦄, ε < c → dist y x < c) ↔ ∀ i > ε, y ∈ ball x i
state_after: no goals
tactic: rfl
Theorem: Prod.card_box_succ
File: Mathlib/Order/Interval/Finset/Box.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : OrderedRing α
inst✝⁵ : OrderedRing β
inst✝⁴ : LocallyFiniteOrder α
inst✝³ : LocallyFiniteOrder β
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
n : ℕ
⊢ (box (n + 1)).card =
    (Icc (-↑n.succ) ↑n.succ).card * (Icc (-↑n.succ) ↑n.succ).card - (Icc (-↑n) ↑n).card * (Icc (-↑n) ↑n).card
state_after: α : Type u_1
β : Type u_2
inst✝⁶ : OrderedRing α
inst✝⁵ : OrderedRing β
inst✝⁴ : LocallyFiniteOrder α
inst✝³ : LocallyFiniteOrder β
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
n : ℕ
⊢ (Icc (-↑n.succ).1 (↑n.succ).1).card * (Icc (-↑n.succ).2 (↑n.succ).2).card -
      (Icc (-↑n).1 (↑n).1).card * (Icc (-↑n).2 (↑n).2).card =
    (Icc (-↑n.succ) ↑n.succ).card * (Icc (-↑n.succ) ↑n.succ).card - (Icc (-↑n) ↑n).card * (Icc (-↑n) ↑n).card
tactic: rw [box_succ_eq_sdiff, card_sdiff (Icc_neg_mono n.le_succ), Prod.card_Icc, Prod.card_Icc]
state_before: α : Type u_1
β : Type u_2
inst✝⁶ : OrderedRing α
inst✝⁵ : OrderedRing β
inst✝⁴ : LocallyFiniteOrder α
inst✝³ : LocallyFiniteOrder β
inst✝² : DecidableEq α
inst✝¹ : DecidableEq β
inst✝ : DecidableRel fun x x_1 => x ≤ x_1
n : ℕ
⊢ (Icc (-↑n.succ).1 (↑n.succ).1).card * (Icc (-↑n.succ).2 (↑n.succ).2).card -
      (Icc (-↑n).1 (↑n).1).card * (Icc (-↑n).2 (↑n).2).card =
    (Icc (-↑n.succ) ↑n.succ).card * (Icc (-↑n.succ) ↑n.succ).card - (Icc (-↑n) ↑n).card * (Icc (-↑n) ↑n).card
state_after: no goals
tactic: rfl
Theorem: YoungDiagram.rowLen_ofRowLens
File: Mathlib/Combinatorics/Young/YoungDiagram.lean

Proof steps:
state_before: w : List ℕ
hw : List.Sorted (fun x x_1 => x ≥ x_1) w
i : Fin w.length
⊢ (ofRowLens w hw).rowLen ↑i = w.get i
state_after: no goals
tactic: simp [rowLen, Nat.find_eq_iff, mem_ofRowLens]
Theorem: Polynomial.qsmul_eq_C_mul
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n : ℕ
inst✝ : DivisionRing R
a : ℚ
f : R[X]
⊢ a • f = C ↑a * f
state_after: no goals
tactic: rw [← Rat.smul_one_eq_cast, ← Polynomial.smul_C, C_1, smul_one_mul]
Theorem: CategoryTheory.IsIso.Iso.inv_hom
File: Mathlib/CategoryTheory/Iso.lean

Proof steps:
state_before: C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ inv f.hom = f.inv
state_after: case hom_inv_id
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ f.hom ≫ f.inv = 𝟙 X
tactic: apply inv_eq_of_hom_inv_id
state_before: case hom_inv_id
C : Type u
inst✝ : Category.{v, u} C
X Y Z : C
f✝ g : X ⟶ Y
h : Y ⟶ Z
f : X ≅ Y
⊢ f.hom ≫ f.inv = 𝟙 X
state_after: no goals
tactic: simp
Theorem: CategoryTheory.ofTypeMonad_map
File: Mathlib/CategoryTheory/Monad/Types.lean

Proof steps:
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α β : Type u
f : α → β
a : (ofTypeFunctor m ⋙ ofTypeFunctor m).obj α
⊢ ((ofTypeFunctor m ⋙ ofTypeFunctor m).map f ≫ joinM) a = (joinM ≫ (ofTypeFunctor m).map f) a
state_after: no goals
tactic: apply joinM_map_map
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (ofTypeFunctor m).obj ((ofTypeFunctor m ⋙ ofTypeFunctor m).obj α)
⊢ ((ofTypeFunctor m).map ({ app := @joinM m inst✝¹, naturality := ⋯ }.app α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    ({ app := @joinM m inst✝¹, naturality := ⋯ }.app ((ofTypeFunctor m).obj α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a
state_after: no goals
tactic: apply joinM_map_joinM
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (𝟭 (Type u)).obj ((ofTypeFunctor m).obj α)
⊢ ({ app := @pure m Applicative.toPure, naturality := ⋯ }.app ((ofTypeFunctor m).obj α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    𝟙 ((𝟭 (Type u)).obj ((ofTypeFunctor m).obj α)) a
state_after: no goals
tactic: apply joinM_pure
state_before: m : Type u → Type u
inst✝¹ : _root_.Monad m
inst✝ : LawfulMonad m
α : Type u
a : (ofTypeFunctor m).obj ((𝟭 (Type u)).obj α)
⊢ ((ofTypeFunctor m).map ({ app := @pure m Applicative.toPure, naturality := ⋯ }.app α) ≫
        { app := @joinM m inst✝¹, naturality := ⋯ }.app α)
      a =
    𝟙 ((ofTypeFunctor m).obj ((𝟭 (Type u)).obj α)) a
state_after: no goals
tactic: apply joinM_map_pure
Theorem: CategoryTheory.Subobject.mk_arrow
File: Mathlib/CategoryTheory/Subobject/Basic.lean

Proof steps:
state_before: C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
P : Subobject X
Q : MonoOver X
⊢ mk (arrow (Quotient.mk'' Q)) = Quotient.mk'' Q
state_after: case intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
P : Subobject X
Q : MonoOver X
e : (Quotient.mk'' Q).out' ≅ Q
⊢ mk (arrow (Quotient.mk'' Q)) = Quotient.mk'' Q
tactic: obtain ⟨e⟩ := @Quotient.mk_out' _ (isIsomorphicSetoid _) Q
state_before: case intro
C : Type u₁
inst✝¹ : Category.{v₁, u₁} C
X Y Z : C
D : Type u₂
inst✝ : Category.{v₂, u₂} D
P : Subobject X
Q : MonoOver X
e : (Quotient.mk'' Q).out' ≅ Q
⊢ mk (arrow (Quotient.mk'' Q)) = Quotient.mk'' Q
state_after: no goals
tactic: exact Quotient.sound' ⟨MonoOver.isoMk (Iso.refl _) ≪≫ e⟩
Theorem: GaussianInt.norm_eq_zero
File: Mathlib/NumberTheory/Zsqrtd/GaussianInt.lean

Proof steps:
state_before: x : ℤ[i]
⊢ norm x = 0 ↔ x = 0
state_after: x : ℤ[i]
⊢ ↑(norm x) = ↑0 ↔ x = 0
tactic: rw [← @Int.cast_inj ℝ _ _ _]
state_before: x : ℤ[i]
⊢ ↑(norm x) = ↑0 ↔ x = 0
state_after: no goals
tactic: simp
Theorem: Cubic.card_roots_le
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 : Cubic R
inst✝³ : CommRing R
inst✝² : CommRing S
φ : R →+* S
inst✝¹ : IsDomain R
inst✝ : DecidableEq R
⊢ P.roots.toFinset.card ≤ 3
state_after: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝³ : CommRing R
inst✝² : CommRing S
φ : R →+* S
inst✝¹ : IsDomain R
inst✝ : DecidableEq R
⊢ card P.toPoly.roots ≤ 3
tactic: apply (toFinset_card_le P.toPoly.roots).trans
state_before: R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝³ : CommRing R
inst✝² : CommRing S
φ : R →+* S
inst✝¹ : IsDomain R
inst✝ : DecidableEq R
⊢ card P.toPoly.roots ≤ 3
state_after: case pos
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝³ : CommRing R
inst✝² : CommRing S
φ : R →+* S
inst✝¹ : IsDomain R
inst✝ : DecidableEq R
hP : P.toPoly = 0
⊢ card P.toPoly.roots ≤ 3

case neg
R : Type u_1
S : Type u_2
F : Type u_3
K : Type u_4
P : Cubic R
inst✝³ : CommRing R
inst✝² : CommRing S
φ : R →+* S
inst✝¹ : IsDomain R
inst✝ : DecidableEq R
hP : ¬P.toPoly = 0
⊢ card P.toPoly.roots ≤ 3
tactic: by_cases hP : P.toPoly = 0
Theorem: List.Nodup.ne_singleton_iff
File: Mathlib/Data/List/Nodup.lean

Proof steps:
state_before: α : Type u
β : Type v
l✝ l₁ l₂ : List α
r : α → α → Prop
a b : α
l : List α
h : l.Nodup
x : α
⊢ l ≠ [x] ↔ l = [] ∨ ∃ y ∈ l, y ≠ x
state_after: case nil
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b x : α
h : [].Nodup
⊢ [] ≠ [x] ↔ [] = [] ∨ ∃ y ∈ [], y ≠ x

case cons
α : Type u
β : Type v
l l₁ l₂ : List α
r : α → α → Prop
a b x hd : α
tl : List α
hl : tl.Nodup → (tl ≠ [x] ↔ tl = [] ∨ ∃ y ∈ tl, y ≠ x)
h : (hd :: tl).Nodup
⊢ hd :: tl ≠ [x] ↔ hd :: tl = [] ∨ ∃ y ∈ hd :: tl, y ≠ x
tactic: induction' l with hd tl hl
Theorem: HNNExtension.of_injective
File: Mathlib/GroupTheory/HNNExtension.lean

Proof steps:
state_before: G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
⊢ Injective ⇑of
state_after: case intro
G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
⊢ Injective ⇑of
tactic: rcases TransversalPair.nonempty G A B with ⟨d⟩
state_before: case intro
G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
⊢ Injective ((fun x x_1 => x • x_1) ∘ ⇑of)
state_after: case intro
G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
a₁✝ a₂✝ : G
h : ((fun x x_1 => x • x_1) ∘ ⇑of) a₁✝ = ((fun x x_1 => x • x_1) ∘ ⇑of) a₂✝
⊢ a₁✝ = a₂✝
tactic: intros _ _ h
state_before: case intro
G : Type u_1
inst✝² : Group G
A B : Subgroup G
φ : ↥A ≃* ↥B
H : Type u_2
inst✝¹ : Group H
M : Type u_3
inst✝ : Monoid M
d : TransversalPair G A B
a₁✝ a₂✝ : G
h : ((fun x x_1 => x • x_1) ∘ ⇑of) a₁✝ = ((fun x x_1 => x • x_1) ∘ ⇑of) a₂✝
⊢ a₁✝ = a₂✝
state_after: no goals
tactic: exact eq_of_smul_eq_smul (fun w : NormalWord d =>
    by simp_all [Function.funext_iff, of_smul_eq_smul])
Theorem: tendsto_atTop_isGLB
File: Mathlib/Topology/Order/MonotoneConvergence.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
inst✝³ : Preorder ι
inst✝² : TopologicalSpace α
inst✝¹ : Preorder α
inst✝ : InfConvergenceClass α
f : ι → α
a : α
h_anti : Antitone f
ha : IsGLB (range f) a
⊢ Tendsto f atTop (𝓝 a)
state_after: no goals
tactic: convert tendsto_atBot_isLUB h_anti.dual ha.dual using 1
Theorem: finsum_eq_finset_sum_of_support_subset
File: Mathlib/Algebra/BigOperators/Finprod.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
G : Type u_4
M : Type u_5
N : Type u_6
inst✝¹ : CommMonoid M
inst✝ : CommMonoid N
f : α → M
s : Finset α
h : mulSupport f ⊆ ↑s
⊢ ⋯.toFinset ⊆ s
state_after: no goals
tactic: simpa [← Finset.coe_subset, Set.coe_toFinset]