ruc-ai4math/mathlib_handler_benchmark_410 huggingface dataset:
Theorem: Submodule.comap_subtype_eq_top
File: Mathlib/Algebra/Module/Submodule/Range.lean

Proof steps:
state_before: R : Type u_1
R₂ : Type u_2
R₃ : Type u_3
K : Type u_4
K₂ : Type u_5
M : Type u_6
M₂ : Type u_7
M₃ : Type u_8
V : Type u_9
V₂ : Type u_10
inst✝⁷ : Semiring R
inst✝⁶ : Semiring R₂
inst✝⁵ : AddCommMonoid M
inst✝⁴ : AddCommMonoid M₂
inst✝³ : Module R M
inst✝² : Module R₂ M₂
p✝ p'✝ : Submodule R M
q : Submodule R₂ M₂
τ₁₂ : R →+* R₂
F : Type u_11
inst✝¹ : FunLike F M M₂
inst✝ : SemilinearMapClass F τ₁₂ M M₂
p p' : Submodule R M
⊢ map p.subtype ⊤ ≤ p' ↔ p ≤ p'
state_after: no goals
tactic: rw [map_subtype_top]
Theorem: Nat.Primrec'.encode
File: Mathlib/Computability/Primrec.lean

Proof steps:
state_before: v : Vector ℕ 0
⊢ 0 = encode v
state_after: v : Vector ℕ 0
⊢ 0 = encode nil
tactic: rw [v.eq_nil]
state_before: v : Vector ℕ 0
⊢ 0 = encode nil
state_after: no goals
tactic: rfl
Theorem: Antitone.map_sSup_le
File: Mathlib/Order/CompleteLattice.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (sSup s) ≤ ⨅ a ∈ s, f a
state_after: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (⨆ a ∈ s, a) ≤ ⨅ a ∈ s, f a
tactic: rw [sSup_eq_iSup]
state_before: α : Type u_1
β : Type u_2
β₂ : Type u_3
γ : Type u_4
ι : Sort u_5
ι' : Sort u_6
κ : ι → Sort u_7
κ' : ι' → Sort u_8
inst✝¹ : CompleteLattice α
f✝ g s✝ t : ι → α
a b : α
inst✝ : CompleteLattice β
s : Set α
f : α → β
hf : Antitone f
⊢ f (⨆ a ∈ s, a) ≤ ⨅ a ∈ s, f a
state_after: no goals
tactic: exact hf.map_iSup₂_le _
Theorem: normalize_eq_zero
File: Mathlib/Algebra/GCDMonoid/Basic.lean

Proof steps:
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
x : α
⊢ x = 0 → normalize x = 0
state_after: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
⊢ normalize 0 = 0
tactic: rintro rfl
state_before: α : Type u_1
inst✝¹ : CancelCommMonoidWithZero α
inst✝ : NormalizationMonoid α
⊢ normalize 0 = 0
state_after: no goals
tactic: exact normalize_zero
Theorem: toIocDiv_apply_right
File: Mathlib/Algebra/Order/ToIntervalMod.lean

Proof steps:
state_before: α : Type u_1
inst✝ : LinearOrderedAddCommGroup α
hα : Archimedean α
p : α
hp : 0 < p
a✝ b c : α
n : ℤ
a : α
⊢ a + p - 0 • p ∈ Set.Ioc a (a + p)
state_after: no goals
tactic: simp [hp]
Theorem: IsSemisimpleModule.exists_simple_submodule
File: Mathlib/RingTheory/SimpleModule.lean

Proof steps:
state_before: ι : Type u_1
R : Type u_2
S : Type u_3
inst✝⁷ : Ring R
inst✝⁶ : Ring S
M : Type u_4
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
m : Submodule R M
N : Type u_5
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : IsSemisimpleModule R M
inst✝ : Nontrivial M
⊢ ∃ m, IsSimpleModule R ↥m
state_after: no goals
tactic: simpa only [isSimpleModule_iff_isAtom] using IsAtomic.exists_atom _
Theorem: GroupFilterBasis.nhds_hasBasis
File: Mathlib/Topology/Algebra/FilterBasis.lean

Proof steps:
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ (𝓝 x₀).HasBasis (fun V => V ∈ B) fun V => (fun y => x₀ * y) '' V
state_after: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ (B.N x₀).HasBasis (fun V => V ∈ B) fun V => (fun y => x₀ * y) '' V
tactic: rw [B.nhds_eq]
state_before: G : Type u
inst✝ : Group G
B✝ B : GroupFilterBasis G
x₀ : G
⊢ (B.N x₀).HasBasis (fun V => V ∈ B) fun V => (fun y => x₀ * y) '' V
state_after: no goals
tactic: apply B.hasBasis
Theorem: IsFractionRing.associated_den_num_inv
File: Mathlib/RingTheory/Localization/NumDen.lean

Proof steps:
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
hx : x ≠ 0
⊢ (algebraMap A K) (num A x⁻¹ * num A x) / (algebraMap A K) (↑(den A x⁻¹) * ↑(den A x)) = 1
state_after: no goals
tactic: simp [mul_div_mul_comm, hx]
state_before: R : Type u_1
inst✝⁹ : CommRing R
M : Submonoid R
S : Type u_2
inst✝⁸ : CommRing S
inst✝⁷ : Algebra R S
P : Type u_3
inst✝⁶ : CommRing P
A : Type u_4
inst✝⁵ : CommRing A
inst✝⁴ : IsDomain A
inst✝³ : UniqueFactorizationMonoid A
K : Type u_5
inst✝² : Field K
inst✝¹ : Algebra A K
inst✝ : IsFractionRing A K
x : K
hx : x ≠ 0
⊢ (algebraMap A K) (num A x * num A x⁻¹) / (algebraMap A K) (↑(den A x) * ↑(den A x⁻¹)) = 1
state_after: no goals
tactic: simp [mul_div_mul_comm, hx]
Theorem: Finset.dens_union_of_disjoint
File: Mathlib/Data/Finset/Density.lean

Proof steps:
state_before: 𝕜 : Type u_1
α : Type u_2
β : Type u_3
inst✝¹ : Fintype α
s t : Finset α
a b : α
inst✝ : DecidableEq α
h : _root_.Disjoint s t
⊢ (s ∪ t).dens = s.dens + t.dens
state_after: no goals
tactic: rw [← disjUnion_eq_union s t h, dens_disjUnion _ _ _]
Theorem: LinearMap.IsSymmetric.orthogonalComplement_iSup_eigenspaces_invariant
File: Mathlib/Analysis/InnerProductSpace/Spectrum.lean

Proof steps:
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
v : E
hv : v ∈ (⨆ μ, eigenspace T μ)ᗮ
⊢ T v ∈ (⨆ μ, eigenspace T μ)ᗮ
state_after: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
v : E
hv : v ∈ ⨅ i, (eigenspace T i)ᗮ
⊢ T v ∈ ⨅ i, (eigenspace T i)ᗮ
tactic: rw [← Submodule.iInf_orthogonal] at hv ⊢
state_before: 𝕜 : Type u_1
inst✝² : RCLike 𝕜
E : Type u_2
inst✝¹ : NormedAddCommGroup E
inst✝ : InnerProductSpace 𝕜 E
T : E →ₗ[𝕜] E
hT : T.IsSymmetric
v : E
hv : v ∈ ⨅ i, (eigenspace T i)ᗮ
⊢ T v ∈ ⨅ i, (eigenspace T i)ᗮ
state_after: no goals
tactic: exact T.iInf_invariant hT.invariant_orthogonalComplement_eigenspace v hv
Theorem: Real.volume_pi_le_diam_pow
File: Mathlib/MeasureTheory/Measure/Lebesgue/Basic.lean

Proof steps:
state_before: ι : Type u_1
inst✝ : Fintype ι
s : Set (ι → ℝ)
⊢ ∏ _i : ι, ↑1 * EMetric.diam s = EMetric.diam s ^ Fintype.card ι
state_after: no goals
tactic: simp only [ENNReal.coe_one, one_mul, Finset.prod_const, Fintype.card]
Theorem: List.map_permutationsAux2'
File: Mathlib/Data/List/Permutation.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
α' : Type u_3
β' : Type u_4
g : α → α'
g' : β → β'
t : α
ts ys : List α
r : List β
f : List α → β
f' : List α' → β'
H : ∀ (a : List α), g' (f a) = f' (map g a)
⊢ map g' (permutationsAux2 t ts r ys f).2 = (permutationsAux2 (g t) (map g ts) (map g' r) (map g ys) f').2
state_after: case nil
α : Type u_1
β : Type u_2
α' : Type u_3
β' : Type u_4
g : α → α'
g' : β → β'
t : α
ts : List α
r : List β
f : List α → β
f' : List α' → β'
H : ∀ (a : List α), g' (f a) = f' (map g a)
⊢ map g' (permutationsAux2 t ts r [] f).2 = (permutationsAux2 (g t) (map g ts) (map g' r) (map g []) f').2

case cons
α : Type u_1
β : Type u_2
α' : Type u_3
β' : Type u_4
g : α → α'
g' : β → β'
t : α
ts : List α
r : List β
ys_hd : α
tail✝ : List α
ys_ih :
  ∀ (f : List α → β) (f' : List α' → β'),
    (∀ (a : List α), g' (f a) = f' (map g a)) →
      map g' (permutationsAux2 t ts r tail✝ f).2 = (permutationsAux2 (g t) (map g ts) (map g' r) (map g tail✝) f').2
f : List α → β
f' : List α' → β'
H : ∀ (a : List α), g' (f a) = f' (map g a)
⊢ map g' (permutationsAux2 t ts r (ys_hd :: tail✝) f).2 =
    (permutationsAux2 (g t) (map g ts) (map g' r) (map g (ys_hd :: tail✝)) f').2
tactic: induction' ys with ys_hd _ ys_ih generalizing f f'
Theorem: Nat.findGreatest_of_not
File: Mathlib/Data/Nat/Find.lean

Proof steps:
state_before: a b c d m n✝ k : ℕ
p q P Q : ℕ → Prop
inst✝ : DecidablePred P
n : ℕ
h : ¬P (n + 1)
⊢ findGreatest P (n + 1) = findGreatest P n
state_after: no goals
tactic: simp [Nat.findGreatest, h]
Theorem: Function.Antiperiodic.smul
File: Mathlib/Algebra/Periodic.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x : α
inst✝³ : Add α
inst✝² : Monoid γ
inst✝¹ : AddGroup β
inst✝ : DistribMulAction γ β
h : Antiperiodic f c
a : γ
⊢ Antiperiodic (a • f) c
state_after: no goals
tactic: simp_all
Theorem: RingQuot.lift_mkRingHom_apply
File: Mathlib/Algebra/RingQuot.lean

Proof steps:
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
x : R
⊢ (lift ⟨f, w⟩) ((mkRingHom r) x) = f x
state_after: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
x : R
⊢ ({
          toFun := fun f =>
            { toFun := fun x => Quot.lift ⇑↑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ },
          invFun := fun F =>
            ⟨F.comp
                { toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
                  map_add' := ⋯ },
              ⋯⟩,
          left_inv := ⋯, right_inv := ⋯ }
        ⟨f, w⟩)
      ({ toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        x) =
    f x
tactic: simp_rw [lift_def, preLift_def, mkRingHom_def]
state_before: R : Type uR
inst✝⁴ : Semiring R
S : Type uS
inst✝³ : CommSemiring S
T : Type uT
A : Type uA
inst✝² : Semiring A
inst✝¹ : Algebra S A
r✝ : R → R → Prop
inst✝ : Semiring T
f : R →+* T
r : R → R → Prop
w : ∀ ⦃x y : R⦄, r x y → f x = f y
x : R
⊢ ({
          toFun := fun f =>
            { toFun := fun x => Quot.lift ⇑↑f ⋯ x.toQuot, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯, map_add' := ⋯ },
          invFun := fun F =>
            ⟨F.comp
                { toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
                  map_add' := ⋯ },
              ⋯⟩,
          left_inv := ⋯, right_inv := ⋯ }
        ⟨f, w⟩)
      ({ toFun := fun x => { toQuot := Quot.mk (Rel r) x }, map_one' := ⋯, map_mul' := ⋯, map_zero' := ⋯,
          map_add' := ⋯ }
        x) =
    f x
state_after: no goals
tactic: rfl
Theorem: List.range_loop_range'
File: .lake/packages/batteries/Batteries/Data/List/Lemmas.lean

Proof steps:
state_before: s n : Nat
⊢ range.loop (s + 1) (range' (s + 1) n) = range' 0 (n + (s + 1))
state_after: s n : Nat
⊢ range.loop (s + 1) (range' (s + 1) n) = range' 0 (n + 1 + s)
tactic: rw [← Nat.add_assoc, Nat.add_right_comm n s 1]
state_before: s n : Nat
⊢ range.loop (s + 1) (range' (s + 1) n) = range' 0 (n + 1 + s)
state_after: no goals
tactic: exact range_loop_range' s (n + 1)
Theorem: map_preNormEDS'
File: Mathlib/NumberTheory/EllipticDivisibilitySequence.lean

Proof steps:
state_before: R : Type u
S : Type v
inst✝¹ : CommRing R
inst✝ : CommRing S
W : ℤ → R
f : R →+* S
b c d : R
n : ℕ
⊢ f (preNormEDS' b c d n) = preNormEDS' (f b) (f c) (f d) n
state_after: no goals
tactic: induction n using normEDSRec' with
  | zero => rw [preNormEDS'_zero, map_zero, preNormEDS'_zero]
  | one => rw [preNormEDS'_one, map_one, preNormEDS'_one]
  | two => rw [preNormEDS'_two, map_one, preNormEDS'_two]
  | three => rw [preNormEDS'_three, preNormEDS'_three]
  | four => rw [preNormEDS'_four, preNormEDS'_four]
  | _ _ ih =>
    simp only [preNormEDS'_odd, preNormEDS'_even, map_one, map_sub, map_mul, map_pow, apply_ite f]
    repeat rw [ih _ <| by linarith only]
Theorem: PartialHomeomorph.isBigOWith_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
C : ℝ
h : IsBigOWith C (𝓝 b) f g
⊢ Tendsto (↑e) (𝓝 (↑e.symm b)) (𝓝 b)
state_after: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
C : ℝ
h : IsBigOWith C (𝓝 b) f g
this : ContinuousAt (↑e) (↑e.symm b)
⊢ Tendsto (↑e) (𝓝 (↑e.symm b)) (𝓝 b)
tactic: have := e.continuousAt (e.map_target hb)
state_before: α : Type u_1
β : Type u_2
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
E : Type u_3
inst✝¹ : Norm E
F : Type u_4
inst✝ : Norm F
e : PartialHomeomorph α β
b : β
hb : b ∈ e.target
f : β → E
g : β → F
C : ℝ
h : IsBigOWith C (𝓝 b) f g
this : ContinuousAt (↑e) (↑e.symm b)
⊢ Tendsto (↑e) (𝓝 (↑e.symm b)) (𝓝 b)
state_after: no goals
tactic: rwa [ContinuousAt, e.rightInvOn hb] at this
Theorem: List.nodup_ofFn_ofInjective
File: Mathlib/Data/List/FinRange.lean

Proof steps:
state_before: α : Type u
n : ℕ
f : Fin n → α
hf : Function.Injective f
⊢ (ofFn f).Nodup
state_after: α : Type u
n : ℕ
f : Fin n → α
hf : Function.Injective f
⊢ (pmap (fun i hi => f ⟨i, hi⟩) (range n) ⋯).Nodup
tactic: rw [ofFn_eq_pmap]
state_before: α : Type u
n : ℕ
f : Fin n → α
hf : Function.Injective f
⊢ (pmap (fun i hi => f ⟨i, hi⟩) (range n) ⋯).Nodup
state_after: no goals
tactic: exact (nodup_range n).pmap fun _ _ _ _ H => Fin.val_eq_of_eq <| hf H
Theorem: Asymptotics.IsEquivalent.isBigO_symm
File: Mathlib/Analysis/Asymptotics/AsymptoticEquivalent.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u ~[l] v
⊢ v =O[l] u
state_after: case h.e'_8.h
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u ~[l] v
x✝ : α
⊢ u x✝ = (u - v) x✝ + v x✝
tactic: convert h.isLittleO.right_isBigO_add
state_before: case h.e'_8.h
α : Type u_1
β : Type u_2
inst✝ : NormedAddCommGroup β
u v w : α → β
l : Filter α
h : u ~[l] v
x✝ : α
⊢ u x✝ = (u - v) x✝ + v x✝
state_after: no goals
tactic: simp
Theorem: CochainComplex.HomComplex.Cochain.d_comp_ofHoms_v
File: Mathlib/Algebra/Homology/HomotopyCategory/HomComplex.lean

Proof steps:
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq : p + 0 = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq = F.d p' q ≫ ψ q
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq✝ : p + 0 = q
hpq : p = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq✝ = F.d p' q ≫ ψ q
tactic: rw [add_zero] at hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p q : ℤ
hpq✝ : p + 0 = q
hpq : p = q
⊢ F.d p' p ≫ (ofHoms ψ).v p q hpq✝ = F.d p' q ≫ ψ q
state_after: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p : ℤ
hpq : p + 0 = p
⊢ F.d p' p ≫ (ofHoms ψ).v p p hpq = F.d p' p ≫ ψ p
tactic: subst hpq
state_before: C : Type u
inst✝³ : Category.{v, u} C
inst✝² : Preadditive C
R : Type u_1
inst✝¹ : Ring R
inst✝ : Linear R C
F G K L : CochainComplex C ℤ
n m : ℤ
ψ : (p : ℤ) → F.X p ⟶ G.X p
p' p : ℤ
hpq : p + 0 = p
⊢ F.d p' p ≫ (ofHoms ψ).v p p hpq = F.d p' p ≫ ψ p
state_after: no goals
tactic: rw [ofHoms_v]
Theorem: ModelWithCorners.prod_symm_apply
File: Mathlib/Geometry/Manifold/SmoothManifoldWithCorners.lean

Proof steps:
state_before: 𝕜 : Type u
inst✝⁶ : NontriviallyNormedField 𝕜
E : Type v
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
H : Type w
inst✝³ : TopologicalSpace H
I : ModelWithCorners 𝕜 E H
E' : Type v'
inst✝² : NormedAddCommGroup E'
inst✝¹ : NormedSpace 𝕜 E'
H' : Type w'
inst✝ : TopologicalSpace H'
I' : ModelWithCorners 𝕜 E' H'
⊢ { toFun := fun x => (↑I x.1, ↑I' x.2), invFun := fun x => (↑I.symm x.1, ↑I'.symm x.2),
        source := {x | x.1 ∈ I.source ∧ x.2 ∈ I'.source}, target := __src✝.target, map_source' := ⋯, map_target' := ⋯,
        left_inv' := ⋯, right_inv' := ⋯ }.source =
    univ
state_after: no goals
tactic: simp only [setOf_true, mfld_simps]
Theorem: norm_smul
File: Mathlib/Analysis/Normed/MulAction.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝³ : NormedDivisionRing α
inst✝² : SeminormedAddGroup β
inst✝¹ : MulActionWithZero α β
inst✝ : BoundedSMul α β
r : α
x : β
⊢ ‖r • x‖ = ‖r‖ * ‖x‖
state_after: case pos
α : Type u_1
β : Type u_2
inst✝³ : NormedDivisionRing α
inst✝² : SeminormedAddGroup β
inst✝¹ : MulActionWithZero α β
inst✝ : BoundedSMul α β
r : α
x : β
h : r = 0
⊢ ‖r • x‖ = ‖r‖ * ‖x‖

case neg
α : Type u_1
β : Type u_2
inst✝³ : NormedDivisionRing α
inst✝² : SeminormedAddGroup β
inst✝¹ : MulActionWithZero α β
inst✝ : BoundedSMul α β
r : α
x : β
h : ¬r = 0
⊢ ‖r • x‖ = ‖r‖ * ‖x‖
tactic: by_cases h : r = 0
Theorem: Option.card_toFinset
File: Mathlib/Data/Finset/Option.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
o : Option α
⊢ o.toFinset.card = o.elim 0 1
state_after: no goals
tactic: cases o <;> rfl
Theorem: List.rtakeWhile_suffix
File: Mathlib/Data/List/DropRight.lean

Proof steps:
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ rtakeWhile p l <:+ l
state_after: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ takeWhile p l.reverse <+: l.reverse
tactic: rw [← reverse_prefix, rtakeWhile, reverse_reverse]
state_before: α : Type u_1
p : α → Bool
l : List α
n : ℕ
⊢ takeWhile p l.reverse <+: l.reverse
state_after: no goals
tactic: exact takeWhile_prefix _
Theorem: ProbabilityTheory.gaussianReal_absolutelyContinuous'
File: Mathlib/Probability/Distributions/Gaussian.lean

Proof steps:
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ℙ ≪ gaussianReal μ v
state_after: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ℙ ≪ ℙ.withDensity (gaussianPDF μ v)
tactic: rw [gaussianReal_of_var_ne_zero _ hv]
state_before: μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ℙ ≪ ℙ.withDensity (gaussianPDF μ v)
state_after: case refine_1
μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ AEMeasurable (gaussianPDF μ v) ℙ

case refine_2
μ : ℝ
v : ℝ≥0
hv : v ≠ 0
⊢ ∀ᵐ (x : ℝ), gaussianPDF μ v x ≠ 0
tactic: refine withDensity_absolutelyContinuous' ?_ ?_
Theorem: Besicovitch.SatelliteConfig.inter'
File: Mathlib/MeasureTheory/Covering/Besicovitch.lean

Proof steps:
state_before: α : Type u_1
inst✝ : MetricSpace α
N : ℕ
τ : ℝ
a : SatelliteConfig α N τ
i : Fin N.succ
⊢ dist (a.c i) (a.c (last N)) ≤ a.r i + a.r (last N)
state_after: case inl
α : Type u_1
inst✝ : MetricSpace α
N : ℕ
τ : ℝ
a : SatelliteConfig α N τ
i : Fin N.succ
H : i < last N
⊢ dist (a.c i) (a.c (last N)) ≤ a.r i + a.r (last N)

case inr
α : Type u_1
inst✝ : MetricSpace α
N : ℕ
τ : ℝ
a : SatelliteConfig α N τ
i : Fin N.succ
H : last N ≤ i
⊢ dist (a.c i) (a.c (last N)) ≤ a.r i + a.r (last N)
tactic: rcases lt_or_le i (last N) with (H | H)
Theorem: Besicovitch.isEmpty_satelliteConfig_multiplicity
File: Mathlib/MeasureTheory/Covering/BesicovitchVectorSpace.lean

Proof steps:
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
⊢ SatelliteConfig E (multiplicity E) (goodτ E) → False
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
⊢ False
tactic: intro a
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
⊢ False
state_after: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := a.centerAndRescale
⊢ False
tactic: let b := a.centerAndRescale
state_before: E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := a.centerAndRescale
⊢ False
state_after: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := a.centerAndRescale
c' : Fin (multiplicity E).succ → E
c'_le_two : ∀ (n : Fin (multiplicity E).succ), ‖c' n‖ ≤ 2
hc' : Pairwise fun i j => 1 - goodδ E ≤ ‖c' i - c' j‖
⊢ False
tactic: rcases b.exists_normalized a.centerAndRescale_center a.centerAndRescale_radius
        (one_lt_goodτ E).le (goodδ E) le_rfl (goodδ_lt_one E).le with
      ⟨c', c'_le_two, hc'⟩
state_before: case intro.intro
E : Type u_1
inst✝² : NormedAddCommGroup E
inst✝¹ : NormedSpace ℝ E
inst✝ : FiniteDimensional ℝ E
a : SatelliteConfig E (multiplicity E) (goodτ E)
b : SatelliteConfig E (multiplicity E) (goodτ E) := a.centerAndRescale
c' : Fin (multiplicity E).succ → E
c'_le_two : ∀ (n : Fin (multiplicity E).succ), ‖c' n‖ ≤ 2
hc' : Pairwise fun i j => 1 - goodδ E ≤ ‖c' i - c' j‖
⊢ False
state_after: no goals
tactic: exact
      lt_irrefl _ ((Nat.lt_succ_self _).trans_le (le_multiplicity_of_δ_of_fin c' c'_le_two hc'))
Theorem: Finset.map_subtype_embedding_Ioi
File: Mathlib/Order/Interval/Finset/Defs.lean

Proof steps:
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Ioi a) = Ioi ↑a
state_after: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioi ↑a)) = Ioi ↑a
tactic: rw [subtype_Ioi_eq]
state_before: α : Type u_1
β : Type u_2
inst✝² : Preorder α
p : α → Prop
inst✝¹ : DecidablePred p
inst✝ : LocallyFiniteOrderTop α
a : Subtype p
hp : ∀ ⦃a x : α⦄, a ≤ x → p a → p x
⊢ map (Embedding.subtype p) (Finset.subtype p (Ioi ↑a)) = Ioi ↑a
state_after: no goals
tactic: exact Finset.subtype_map_of_mem fun x hx => hp (mem_Ioi.1 hx).le a.prop
Theorem: CategoryTheory.shiftComm_hom_comp
File: Mathlib/CategoryTheory/Shift/Basic.lean

Proof steps:
state_before: C : Type u
A : Type u_1
inst✝² : Category.{v, u} C
inst✝¹ : AddCommMonoid A
inst✝ : HasShift C A
X Y : C
f : X ⟶ Y
i j : A
⊢ (shiftComm X i j).hom ≫ (shiftFunctor C i).map ((shiftFunctor C j).map f) =
    (shiftFunctor C j).map ((shiftFunctor C i).map f) ≫ (shiftComm Y i j).hom
state_after: no goals
tactic: rw [shiftComm', ← shiftComm_symm, Iso.symm_hom, Iso.inv_hom_id_assoc]
Theorem: Complex.frontier_setOf_im_lt
File: Mathlib/Analysis/Complex/ReImTopology.lean

Proof steps:
state_before: a : ℝ
⊢ frontier {z | z.im < a} = {z | z.im = a}
state_after: no goals
tactic: simpa only [frontier_Iio] using frontier_preimage_im (Iio a)