ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: affineIndependent_of_ne_of_mem_of_not_mem_of_mem
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

Proof steps:
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k ![p₁, p₂, p₃]
state_after: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2))
tactic: rw [← affineIndependent_equiv (Equiv.swap (1 : Fin 3) 2)]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ AffineIndependent k (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2))
state_after: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2) = ![p₁, p₃, p₂]
tactic: convert affineIndependent_of_ne_of_mem_of_mem_of_not_mem hp₁p₃ hp₁ hp₃ hp₂ using 1
state_before: case h.e'_9
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
⊢ ![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2) = ![p₁, p₃, p₂]
state_after: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2)) x = ![p₁, p₃, p₂] x
tactic: ext x
state_before: case h.e'_9.h
k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : DivisionRing k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
ι : Type u_4
s : AffineSubspace k P
p₁ p₂ p₃ : P
hp₁p₃ : p₁ ≠ p₃
hp₁ : p₁ ∈ s
hp₂ : p₂ ∉ s
hp₃ : p₃ ∈ s
x : Fin 3
⊢ (![p₁, p₂, p₃] ∘ ⇑(Equiv.swap 1 2)) x = ![p₁, p₃, p₂] x
state_after: no goals
tactic: fin_cases x <;> rfl
Theorem: Matrix.PosSemidef.submatrix
File: Mathlib/LinearAlgebra/Matrix/PosDef.lean

Proof steps:
state_before: m : Type u_1
n : Type u_2
R : Type u_3
𝕜 : Type u_4
inst✝⁶ : Fintype m
inst✝⁵ : Fintype n
inst✝⁴ : CommRing R
inst✝³ : PartialOrder R
inst✝² : StarRing R
inst✝¹ : StarOrderedRing R
inst✝ : RCLike 𝕜
M : Matrix n n R
hM : M.PosSemidef
e : m → n
⊢ (M.submatrix e e).PosSemidef
state_after: no goals
tactic: classical
  rw [(by simp : M = 1 * M * 1), submatrix_mul (he₂ := Function.bijective_id),
    submatrix_mul (he₂ := Function.bijective_id), submatrix_id_id]
  simpa only [conjTranspose_submatrix, conjTranspose_one] using
    conjTranspose_mul_mul_same hM (Matrix.submatrix 1 id e)
Theorem: Equiv.ofLeftInverse_eq_ofInjective
File: Mathlib/Logic/Equiv/Set.lean

Proof steps:
state_before: α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : Nonempty α → β → α
hf : ∀ (h : Nonempty α), LeftInverse (f_inv h) f
⊢ ofLeftInverse f f_inv hf = ofInjective f ⋯
state_after: case H.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : Nonempty α → β → α
hf : ∀ (h : Nonempty α), LeftInverse (f_inv h) f
x✝ : α
⊢ ↑((ofLeftInverse f f_inv hf) x✝) = ↑((ofInjective f ⋯) x✝)
tactic: ext
state_before: case H.a
α✝ : Sort u
β✝ : Sort v
γ : Sort w
α : Type u_1
β : Type u_2
f : α → β
f_inv : Nonempty α → β → α
hf : ∀ (h : Nonempty α), LeftInverse (f_inv h) f
x✝ : α
⊢ ↑((ofLeftInverse f f_inv hf) x✝) = ↑((ofInjective f ⋯) x✝)
state_after: no goals
tactic: simp
Theorem: SchwartzMap.integralCLM_dirac_eq_delta
File: Mathlib/Analysis/Distribution/SchwartzSpace.lean

Proof steps:
state_before: 𝕜 : Type u_1
𝕜' : Type u_2
D : Type u_3
E : Type u_4
F : Type u_5
G : Type u_6
V : Type u_7
inst✝¹⁰ : NormedAddCommGroup E
inst✝⁹ : NormedSpace ℝ E
inst✝⁸ : NormedAddCommGroup F
inst✝⁷ : NormedSpace ℝ F
inst✝⁶ : RCLike 𝕜
inst✝⁵ : NormedSpace 𝕜 F
inst✝⁴ : SMulCommClass ℝ 𝕜 F
inst✝³ : MeasurableSpace E
inst✝² : BorelSpace E
inst✝¹ : SecondCountableTopology E
inst✝ : CompleteSpace F
x : E
⊢ integralCLM 𝕜 (dirac x) = delta 𝕜 F x
state_after: no goals
tactic: aesop
Theorem: Function.minimalPeriod_eq_minimalPeriod_iff
File: Mathlib/Dynamics/PeriodicPts.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
f fa : α → α
fb : β → β
x y✝ : α
m n : ℕ
g : β → β
y : β
⊢ minimalPeriod f x = minimalPeriod g y ↔ ∀ (n : ℕ), IsPeriodicPt f n x ↔ IsPeriodicPt g n y
state_after: no goals
tactic: simp_rw [isPeriodicPt_iff_minimalPeriod_dvd, dvd_right_iff_eq]
Theorem: mem_nhds_induced
File: Mathlib/Topology/Order.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
state_after: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
tactic: letI := T.induced f
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ s ∈ 𝓝 a ↔ ∃ u ∈ 𝓝 (f a), f ⁻¹' u ⊆ s
state_after: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) ↔ ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s
tactic: simp_rw [mem_nhds_iff, isOpen_induced_iff]
state_before: α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) ↔ ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s
state_after: case mp
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t) → ∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s

case mpr
α : Type u
β : Type v
γ : Type u_1
f✝ : α → β
ι : Sort u_2
T : TopologicalSpace α
f : β → α
a : β
s : Set β
this : TopologicalSpace β := induced f T
⊢ (∃ u, (∃ t ⊆ u, IsOpen t ∧ f a ∈ t) ∧ f ⁻¹' u ⊆ s) → ∃ t ⊆ s, (∃ t_1, IsOpen t_1 ∧ f ⁻¹' t_1 = t) ∧ a ∈ t
tactic: constructor
Theorem: AddChar.mulShift_mulShift
File: Mathlib/Algebra/Group/AddChar.lean

Proof steps:
state_before: R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s : R
⊢ (ψ.mulShift r).mulShift s = ψ.mulShift (r * s)
state_after: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ ((ψ.mulShift r).mulShift s) x✝ = (ψ.mulShift (r * s)) x✝
tactic: ext
state_before: case h
R : Type u_1
M : Type u_2
inst✝¹ : Ring R
inst✝ : CommMonoid M
ψ : AddChar R M
r s x✝ : R
⊢ ((ψ.mulShift r).mulShift s) x✝ = (ψ.mulShift (r * s)) x✝
state_after: no goals
tactic: simp only [mulShift_apply, mul_assoc]
Theorem: Nat.add_div_eq_of_add_mod_lt
File: Mathlib/Data/Nat/ModEq.lean

Proof steps:
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc : a % c + b % c < c
hc0 : c = 0
⊢ (a + b) / c = a / c + b / c
state_after: no goals
tactic: simp [hc0]
state_before: m n a✝ b✝ c✝ d a b c : ℕ
hc : a % c + b % c < c
hc0 : ¬c = 0
⊢ (a + b) / c = a / c + b / c
state_after: no goals
tactic: rw [add_div (Nat.pos_of_ne_zero hc0), if_neg (not_le_of_lt hc), add_zero]
Theorem: PadicInt.appr_mono
File: Mathlib/NumberTheory/Padics/RingHoms.lean

Proof steps:
state_before: p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ Monotone x.appr
state_after: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (n : ℕ), x.appr n ≤ x.appr (n + 1)
tactic: apply monotone_nat_of_le_succ
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
⊢ ∀ (n : ℕ), x.appr n ≤ x.appr (n + 1)
state_after: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ x.appr n ≤ x.appr (n + 1)
tactic: intro n
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ x.appr n ≤ x.appr (n + 1)
state_after: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ x.appr n ≤
    if hy : x - ↑(x.appr n) = 0 then x.appr n
    else x.appr n + p ^ n * (toZMod (↑(unitCoeff hy) * ↑p ^ ((x - ↑(x.appr n)).valuation - ↑n).natAbs)).val
tactic: dsimp [appr]
state_before: case hf
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
⊢ x.appr n ≤
    if hy : x - ↑(x.appr n) = 0 then x.appr n
    else x.appr n + p ^ n * (toZMod (↑(unitCoeff hy) * ↑p ^ ((x - ↑(x.appr n)).valuation - ↑n).natAbs)).val
state_after: case pos
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
h✝ : x - ↑(x.appr n) = 0
⊢ x.appr n ≤ x.appr n

case neg
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
h✝ : ¬x - ↑(x.appr n) = 0
⊢ x.appr n ≤ x.appr n + p ^ n * (toZMod (↑(unitCoeff h✝) * ↑p ^ ((x - ↑(x.appr n)).valuation - ↑n).natAbs)).val
tactic: split_ifs
state_before: case neg
p : ℕ
hp_prime : Fact (Nat.Prime p)
r : ℚ
x✝ x : ℤ_[p]
n : ℕ
h✝ : ¬x - ↑(x.appr n) = 0
⊢ x.appr n ≤ x.appr n + p ^ n * (toZMod (↑(unitCoeff h✝) * ↑p ^ ((x - ↑(x.appr n)).valuation - ↑n).natAbs)).val
state_after: no goals
tactic: apply Nat.le_add_right
Theorem: List.chain'_range_succ
File: Mathlib/Data/List/Range.lean

Proof steps:
state_before: α : Type u
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain' r (range n.succ) ↔ ∀ m < n, r m m.succ
state_after: α : Type u
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain' r (range n ++ [n]) ↔ ∀ m < n, r m m.succ
tactic: rw [range_succ]
state_before: α : Type u
r : ℕ → ℕ → Prop
n : ℕ
⊢ Chain' r (range n ++ [n]) ↔ ∀ m < n, r m m.succ
state_after: case zero
α : Type u
r : ℕ → ℕ → Prop
⊢ Chain' r (range 0 ++ [0]) ↔ ∀ m < 0, r m m.succ

case succ
α : Type u
r : ℕ → ℕ → Prop
n : ℕ
hn : Chain' r (range n ++ [n]) ↔ ∀ m < n, r m m.succ
⊢ Chain' r (range (n + 1) ++ [n + 1]) ↔ ∀ m < n + 1, r m m.succ
tactic: induction' n with n hn
Theorem: AlgebraicGeometry.IsAffineOpen.isLocalization_of_eq_basicOpen
File: Mathlib/AlgebraicGeometry/AffineScheme.lean

Proof steps:
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
V : X.Opens
i : V ⟶ U
e : V = X.basicOpen f
⊢ IsLocalization.Away f ↑Γ(X, V)
state_after: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
i : X.basicOpen f ⟶ U
⊢ IsLocalization.Away f ↑Γ(X, X.basicOpen f)
tactic: subst e
state_before: X Y : Scheme
U : X.Opens
hU : IsAffineOpen U
f : ↑Γ(X, U)
i : X.basicOpen f ⟶ U
⊢ IsLocalization.Away f ↑Γ(X, X.basicOpen f)
state_after: no goals
tactic: convert isLocalization_basicOpen hU f using 3
Theorem: isCompact_singleton
File: Mathlib/Topology/Compactness/Compact.lean

Proof steps:
state_before: X : Type u
Y : Type v
ι : Type u_1
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
s t : Set X
x : X
f : Filter X
hf : f.NeBot
hfa : f ≤ 𝓟 {x}
⊢ 𝓟 {x} ≤ 𝓝 x
state_after: no goals
tactic: simpa only [principal_singleton] using pure_le_nhds x
Theorem: Path.trans_symm
File: Mathlib/Topology/Connected/PathConnected.lean

Proof steps:
state_before: X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
⊢ (γ.trans γ').symm = γ'.symm.trans γ.symm
state_after: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (γ.trans γ').symm t = (γ'.symm.trans γ.symm) t
tactic: ext t
state_before: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (γ.trans γ').symm t = (γ'.symm.trans γ.symm) t
state_after: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if h : ↑(σ t) ≤ 1 / 2 then γ ⟨2 * ↑(σ t), ⋯⟩ else γ' ⟨2 * ↑(σ t) - 1, ⋯⟩) =
    if h : ↑t ≤ 1 / 2 then γ' (σ ⟨2 * ↑t, ⋯⟩) else γ (σ ⟨2 * ↑t - 1, ⋯⟩)
tactic: simp only [trans_apply, ← one_div, symm_apply, not_le, Function.comp_apply]
state_before: case a.h
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
⊢ (if h : ↑(σ t) ≤ 1 / 2 then γ ⟨2 * ↑(σ t), ⋯⟩ else γ' ⟨2 * ↑(σ t) - 1, ⋯⟩) =
    if h : ↑t ≤ 1 / 2 then γ' (σ ⟨2 * ↑t, ⋯⟩) else γ (σ ⟨2 * ↑t - 1, ⋯⟩)
state_after: case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ↑t ≤ 1 / 2
⊢ γ ⟨2 * ↑(σ t), ⋯⟩ = γ' (σ ⟨2 * ↑t, ⋯⟩)

case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ↑(σ t) ≤ 1 / 2
h : 1 - ↑t ≤ 1 / 2
h₁ : ¬↑t ≤ 1 / 2
⊢ γ ⟨2 * ↑(σ t), ⋯⟩ = γ (σ ⟨2 * ↑t - 1, ⋯⟩)

case pos
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ↑t ≤ 1 / 2
⊢ γ' ⟨2 * ↑(σ t) - 1, ⋯⟩ = γ' (σ ⟨2 * ↑t, ⋯⟩)

case neg
X : Type u_1
Y : Type u_2
inst✝¹ : TopologicalSpace X
inst✝ : TopologicalSpace Y
x y z : X
ι : Type u_3
γ✝ γ : Path x y
γ' : Path y z
t : ↑I
h✝ : ¬↑(σ t) ≤ 1 / 2
h : ¬1 - ↑t ≤ 1 / 2
h₂ : ¬↑t ≤ 1 / 2
⊢ γ' ⟨2 * ↑(σ t) - 1, ⋯⟩ = γ (σ ⟨2 * ↑t - 1, ⋯⟩)
tactic: split_ifs with h h₁ h₂ <;> rw [coe_symm_eq] at h
Theorem: Nat.factorial_inj'
File: Mathlib/Data/Nat/Factorial/Basic.lean

Proof steps:
state_before: m n : ℕ
h : 1 < n ∨ 1 < m
⊢ n ! = m ! ↔ n = m
state_after: case inl
m n : ℕ
hn : 1 < n
⊢ n ! = m ! ↔ n = m

case inr
m n : ℕ
hm : 1 < m
⊢ n ! = m ! ↔ n = m
tactic: obtain hn|hm := h
Theorem: AddAction.aestabilizer_congr
File: Mathlib/MeasureTheory/Group/AEStabilizer.lean

Proof steps:
state_before: G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g : G
s t : Set α
h : s =ᶠ[ae μ] t
⊢ aestabilizer G μ s = aestabilizer G μ t
state_after: case h
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g✝ : G
s t : Set α
h : s =ᶠ[ae μ] t
g : G
⊢ g ∈ aestabilizer G μ s ↔ g ∈ aestabilizer G μ t
tactic: ext g
state_before: case h
G : Type u_1
α : Type u_2
inst✝² : Group G
inst✝¹ : MulAction G α
x✝ : MeasurableSpace α
μ : Measure α
inst✝ : SMulInvariantMeasure G α μ
g✝ : G
s t : Set α
h : s =ᶠ[ae μ] t
g : G
⊢ g ∈ aestabilizer G μ s ↔ g ∈ aestabilizer G μ t
state_after: no goals
tactic: rw [mem_aestabilizer, mem_aestabilizer, h.congr_right, ((smul_set_ae_eq g).2 h).congr_left]
Theorem: List.mem_zip_inits_tails
File: Mathlib/Data/List/Zip.lean

Proof steps:
state_before: α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
l init tail : List α
⊢ (init, tail) ∈ l.inits.zip l.tails ↔ init ++ tail = l
state_after: case nil
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
init tail : List α
⊢ (init, tail) ∈ ([], []) :: [].zip [] ↔ init ++ tail = []

case cons
α : Type u
β : Type u_1
γ : Type u_2
δ : Type u_3
ε : Type u_4
hd : α
tl : List α
ih : ∀ {init tail : List α}, (init, tail) ∈ tl.inits.zip tl.tails ↔ init ++ tail = tl
init tail : List α
⊢ (init, tail) ∈ ([], hd :: tl) :: (map (fun t => hd :: t) tl.inits).zip tl.tails ↔ init ++ tail = hd :: tl
tactic: induction' l with hd tl ih generalizing init tail <;> simp_rw [tails, inits, zip_cons_cons]
Theorem: HasProd.mul_isCompl
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
inst✝² : CommMonoid α
inst✝¹ : TopologicalSpace α
f g : β → α
a b : α
s✝ : Finset β
inst✝ : ContinuousMul α
s t : Set β
hs : IsCompl s t
ha : HasProd (f ∘ Subtype.val) a
hb : HasProd (f ∘ Subtype.val) b
⊢ HasProd f (a * b)
state_after: no goals
tactic: simpa [← hs.compl_eq] using
    (hasProd_subtype_iff_mulIndicator.1 ha).mul (hasProd_subtype_iff_mulIndicator.1 hb)
Theorem: LieSubmodule.trace_eq_trace_restrict_of_le_idealizer
File: Mathlib/Algebra/Lie/TraceForm.lean

Proof steps:
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ (trace R M) (φ x ∘ₗ φ y) = (trace R ↥↑N) ((φ x ∘ₗ φ y).restrict hy')
state_after: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ ∀ (m : M), ⁅x, ⁅y, m⁆⁆ ∈ N
tactic: suffices ∀ m, ⁅x, ⁅y, m⁆⁆ ∈ N by simp [(φ x ∘ₗ φ y).trace_restrict_eq_of_forall_mem _ this]
state_before: R : Type u_1
K : Type u_2
L : Type u_3
M : Type u_4
inst✝¹⁰ : CommRing R
inst✝⁹ : LieRing L
inst✝⁸ : LieAlgebra R L
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : Module.Free R M
inst✝² : Module.Finite R M
inst✝¹ : IsDomain R
inst✝ : IsPrincipalIdealRing R
N : LieSubmodule R L M
I : LieIdeal R L
h : I ≤ N.idealizer
x y : L
hy : y ∈ I
hy' : optParam (∀ m ∈ N, (φ x ∘ₗ φ y) m ∈ N) ⋯
⊢ ∀ (m : M), ⁅x, ⁅y, m⁆⁆ ∈ N
state_after: no goals
tactic: exact fun m ↦ N.lie_mem (h hy m)
Theorem: ConvexOn.map_sum_le
File: Mathlib/Analysis/Convex/Jensen.lean

Proof steps:
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
β : Type u_4
ι : Type u_5
inst✝⁵ : LinearOrderedField 𝕜
inst✝⁴ : AddCommGroup E
inst✝³ : OrderedAddCommGroup β
inst✝² : Module 𝕜 E
inst✝¹ : Module 𝕜 β
inst✝ : OrderedSMul 𝕜 β
s : Set E
f : E → β
t : Finset ι
w : ι → 𝕜
p : ι → E
v : 𝕜
q : E
hf : ConvexOn 𝕜 s f
h₀ : ∀ i ∈ t, 0 ≤ w i
h₁ : ∑ i ∈ t, w i = 1
hmem : ∀ i ∈ t, p i ∈ s
⊢ f (∑ i ∈ t, w i • p i) ≤ ∑ i ∈ t, w i • f (p i)
state_after: no goals
tactic: simpa only [centerMass, h₁, inv_one, one_smul] using
    hf.map_centerMass_le h₀ (h₁.symm ▸ zero_lt_one) hmem
Theorem: tendsto_self_mul_const_pow_of_abs_lt_one
File: Mathlib/Analysis/SpecificLimits/Normed.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
ι : Type u_3
r : ℝ
hr : |r| < 1
⊢ Tendsto (fun n => ↑n * r ^ n) atTop (𝓝 0)
state_after: no goals
tactic: simpa only [pow_one] using tendsto_pow_const_mul_const_pow_of_abs_lt_one 1 hr
Theorem: Real.mul_lt_sin
File: Mathlib/Analysis/SpecialFunctions/Trigonometric/Complex.lean

Proof steps:
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ 2 / π * x < sin x
state_after: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < sin x
tactic: rw [← inv_div]
state_before: x : ℝ
hx : 0 < x
hx' : x < π / 2
⊢ (π / 2)⁻¹ * x < sin x
state_after: no goals
tactic: simpa [-inv_div, mul_inv_cancel_left₀ pi_div_two_pos.ne'] using @lt_sin_mul ((π / 2)⁻¹ * x)
    (mul_pos (inv_pos.2 pi_div_two_pos) hx) (by rwa [← div_eq_inv_mul, div_lt_one pi_div_two_pos])
Theorem: neg_one_pow_eq_or
File: Mathlib/Algebra/Ring/Commute.lean

Proof steps:
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
n : ℕ
h : (-1) ^ n = -1
⊢ (-1) ^ (n + 1) = 1
state_after: no goals
tactic: rw [pow_succ, h, neg_one_mul, neg_neg]
state_before: α : Type u
β : Type v
γ : Type w
R : Type x
inst✝¹ : Monoid R
inst✝ : HasDistribNeg R
n : ℕ
h : (-1) ^ n = 1
⊢ (-1) ^ (n + 1) = -1
state_after: no goals
tactic: rw [pow_succ, h, one_mul]
Theorem: MeasureTheory.Measure.haveLebesgueDecomposition_spec
File: Mathlib/MeasureTheory/Decomposition/Lebesgue.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : μ.HaveLebesgueDecomposition ν
⊢ Measurable (μ.rnDeriv ν) ∧ μ.singularPart ν ⟂ₘ ν ∧ μ = μ.singularPart ν + ν.withDensity (μ.rnDeriv ν)
state_after: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : μ.HaveLebesgueDecomposition ν
⊢ Measurable (Classical.choose ⋯).2 ∧
    (Classical.choose ⋯).1 ⟂ₘ ν ∧ μ = (Classical.choose ⋯).1 + ν.withDensity (Classical.choose ⋯).2
tactic: rw [singularPart, rnDeriv, dif_pos h, dif_pos h]
state_before: α : Type u_1
β : Type u_2
m : MeasurableSpace α
μ✝ ν✝ μ ν : Measure α
h : μ.HaveLebesgueDecomposition ν
⊢ Measurable (Classical.choose ⋯).2 ∧
    (Classical.choose ⋯).1 ⟂ₘ ν ∧ μ = (Classical.choose ⋯).1 + ν.withDensity (Classical.choose ⋯).2
state_after: no goals
tactic: exact Classical.choose_spec h.lebesgue_decomposition
Theorem: Set.Finite.latticeClosure
File: Mathlib/Order/SupClosed.lean

Proof steps:
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DistribLattice α
inst✝ : DistribLattice β
s : Set α
hs : s.Finite
⊢ (_root_.latticeClosure s).Finite
state_after: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DistribLattice α
inst✝ : DistribLattice β
s : Set α
hs : s.Finite
⊢ (supClosure (infClosure s)).Finite
tactic: rw [← supClosure_infClosure]
state_before: F : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : DistribLattice α
inst✝ : DistribLattice β
s : Set α
hs : s.Finite
⊢ (supClosure (infClosure s)).Finite
state_after: no goals
tactic: exact hs.infClosure.supClosure
Theorem: abs_mem_iff
File: Mathlib/Algebra/Group/Subgroup/Order.lean

Proof steps:
state_before: S : Type u_1
G : Type u_2
inst✝² : AddGroup G
inst✝¹ : LinearOrder G
x✝ : SetLike S G
inst✝ : NegMemClass S G
H : S
x : G
⊢ |x| ∈ H ↔ x ∈ H
state_after: no goals
tactic: cases abs_choice x <;> simp [*]
Theorem: Polynomial.trailingDegree_eq_top
File: Mathlib/Algebra/Polynomial/Degree/TrailingDegree.lean

Proof steps:
state_before: R : Type u
S : Type v
a b : R
n m : ℕ
inst✝ : Semiring R
p q r : R[X]
h : p = 0
⊢ p.trailingDegree = ⊤
state_after: no goals
tactic: simp [h]
Theorem: covBy_sup_of_inf_covBy_of_inf_covBy_right
File: Mathlib/Order/ModularLattice.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakUpperModularLattice α
a b : α
⊢ a ⊓ b ⋖ a → a ⊓ b ⋖ b → b ⋖ a ⊔ b
state_after: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakUpperModularLattice α
a b : α
⊢ b ⊓ a ⋖ a → b ⊓ a ⋖ b → b ⋖ b ⊔ a
tactic: rw [inf_comm, sup_comm]
state_before: α : Type u_1
inst✝¹ : Lattice α
inst✝ : IsWeakUpperModularLattice α
a b : α
⊢ b ⊓ a ⋖ a → b ⊓ a ⋖ b → b ⋖ b ⊔ a
state_after: no goals
tactic: exact fun ha hb => covBy_sup_of_inf_covBy_of_inf_covBy_left hb ha
Theorem: Nat.add_eq_zero
File: Mathlib/Data/Nat/Defs.lean

Proof steps:
state_before: a b c d m n k : ℕ
p q : ℕ → Prop
⊢ m + n = 0 ↔ m = 0 ∧ n = 0
state_after: no goals
tactic: omega
Theorem: Polynomial.support_monomial
File: Mathlib/Algebra/Polynomial/Basic.lean

Proof steps:
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
H : a ≠ 0
⊢ ((monomial n) a).support = {n}
state_after: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
H : a ≠ 0
⊢ (match { toFinsupp := Finsupp.single n a } with
    | { toFinsupp := p } => p.support) =
    {n}
tactic: rw [← ofFinsupp_single, support]
state_before: R : Type u
a✝ b : R
m n✝ : ℕ
inst✝ : Semiring R
p q : R[X]
n : ℕ
a : R
H : a ≠ 0
⊢ (match { toFinsupp := Finsupp.single n a } with
    | { toFinsupp := p } => p.support) =
    {n}
state_after: no goals
tactic: exact Finsupp.support_single_ne_zero _ H
Theorem: RCLike.normSq_neg
File: Mathlib/Analysis/RCLike/Basic.lean

Proof steps:
state_before: K : Type u_1
E : Type u_2
inst✝ : RCLike K
z✝ z : K
⊢ normSq (-z) = normSq z
state_after: no goals
tactic: simp only [normSq_eq_def', norm_neg]