tasksource/leandojo huggingface dataset:
Theorem: conformalAt_iff_isConformalMap_fderiv
File: Mathlib/Analysis/Calculus/Conformal/NormedSpace.lean

tactic: constructor
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
⊢ ConformalAt f x ↔ IsConformalMap (fderiv ℝ f x)

tactic: rintro ⟨f', hf, hf'⟩
state_before: case mp
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
⊢ ConformalAt f x → IsConformalMap (fderiv ℝ f x)

tactic: rwa [hf.fderiv]
state_before: case mp.intro.intro
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
f' : X →L[ℝ] Y
hf : HasFDerivAt f f' x
hf' : IsConformalMap f'
⊢ IsConformalMap (fderiv ℝ f x)

tactic: intro H
state_before: case mpr
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
⊢ IsConformalMap (fderiv ℝ f x) → ConformalAt f x

tactic: by_cases h : DifferentiableAt ℝ f x
state_before: case mpr
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
⊢ ConformalAt f x

tactic: exact ⟨fderiv ℝ f x, h.hasFDerivAt, H⟩
state_before: case pos
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
h : DifferentiableAt ℝ f x
⊢ ConformalAt f x

tactic: nontriviality X
state_before: case neg
X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
h : ¬DifferentiableAt ℝ f x
⊢ ConformalAt f x

tactic: exact absurd (fderiv_zero_of_not_differentiableAt h) H.ne_zero
state_before: X : Type u_1
Y : Type u_2
Z : Type ?u.68199
inst✝⁵ : NormedAddCommGroup X
inst✝⁴ : NormedAddCommGroup Y
inst✝³ : NormedAddCommGroup Z
inst✝² : NormedSpace ℝ X
inst✝¹ : NormedSpace ℝ Y
inst✝ : NormedSpace ℝ Z
f : X → Y
x : X
H : IsConformalMap (fderiv ℝ f x)
h : ¬DifferentiableAt ℝ f x
✝ : Nontrivial X
⊢ ConformalAt f x
Theorem: LazyList.append_nil
File: Mathlib/Data/LazyList/Basic.lean

tactic: induction' xs using LazyList.rec with _ _ _ _ ih
state_before: α : Type u_1
xs : LazyList α
⊢ append xs (Thunk.pure nil) = xs

tactic: rfl
state_before: case nil
α : Type u_1
⊢ append nil (Thunk.pure nil) = nil

tactic: simpa only [append, cons.injEq, true_and]
state_before: case cons
α : Type u_1
xs : LazyList α
hd✝ : α
tl✝ : Thunk (LazyList α)
tl_ih✝ : ?m.62837 tl✝
⊢ append (cons hd✝ tl✝) (Thunk.pure nil) = cons hd✝ tl✝

tactic: ext
state_before: case mk
α : Type u_1
xs : LazyList α
fn✝ : Unit → LazyList α
ih : ∀ (a : Unit), append (fn✝ a) (Thunk.pure nil) = fn✝ a
⊢ { fn := fun x => append (Thunk.get { fn := fn✝ }) (Thunk.pure nil) } = { fn := fn✝ }

tactic: apply ih
state_before: case mk.eq
α : Type u_1
xs : LazyList α
fn✝ : Unit → LazyList α
ih : ∀ (a : Unit), append (fn✝ a) (Thunk.pure nil) = fn✝ a
⊢ Thunk.get { fn := fun x => append (Thunk.get { fn := fn✝ }) (Thunk.pure nil) } = Thunk.get { fn := fn✝ }
Theorem: Std.RBNode.All_def
File: Std/Data/RBMap/Lemmas.lean

tactic: induction t <;> simp [or_imp, forall_and, *]
state_before: α : Type u_1
p : α → Prop
t : RBNode α
⊢ All p t ↔ ∀ (x : α), x ∈ t → p x
Theorem: inner_add_right
File: Mathlib/Analysis/InnerProductSpace/Basic.lean

tactic: rw [← inner_conj_symm, inner_add_left, RingHom.map_add]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1221416
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y z : E
⊢ inner x (y + z) = inner x y + inner x z

tactic: simp only [inner_conj_symm]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type ?u.1221416
inst✝⁴ : IsROrC 𝕜
inst✝³ : NormedAddCommGroup E
inst✝² : InnerProductSpace 𝕜 E
inst✝¹ : NormedAddCommGroup F
inst✝ : InnerProductSpace ℝ F
dec_E : DecidableEq E
x y z : E
⊢ ↑(starRingEnd 𝕜) (inner y x) + ↑(starRingEnd 𝕜) (inner z x) = inner x y + inner x z
Theorem: Order.isSuccLimitRecOn_limit
File: Mathlib/Order/SuccPred/Limit.lean

tactic: classical exact dif_pos hb
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hs : (a : α) → ¬IsMax a → C (succ a)
hl : (a : α) → IsSuccLimit a → C a
hb : IsSuccLimit b
⊢ isSuccLimitRecOn b hs hl = hl b hb

tactic: exact dif_pos hb
state_before: α : Type u_1
inst✝¹ : PartialOrder α
inst✝ : SuccOrder α
a b : α
C : α → Sort u_2
hs : (a : α) → ¬IsMax a → C (succ a)
hl : (a : α) → IsSuccLimit a → C a
hb : IsSuccLimit b
⊢ isSuccLimitRecOn b hs hl = hl b hb
Theorem: Computable.option_bind
File: Mathlib/Computability/Partrec.lean

tactic: cases f a <;> rfl
state_before: α : Type u_3
β : Type u_1
γ : Type ?u.184893
σ : Type u_2
inst✝³ : Primcodable α
inst✝² : Primcodable β
inst✝¹ : Primcodable γ
inst✝ : Primcodable σ
f : α → Option β
g : α → β → Option σ
hf : Computable f
hg : Computable₂ g
a : α
⊢ Option.casesOn (f a) Option.none (g a) = Option.bind (f a) (g a)
Theorem: Nat.not_coprime_of_dvd_of_dvd
File: Std/Data/Nat/Gcd.lean

tactic: rw [← co.gcd_eq_one]
state_before: d m n : Nat
dgt1 : 1 < d
Hm : d ∣ m
Hn : d ∣ n
co : coprime m n
⊢ d ∣ 1

tactic: exact dvd_gcd Hm Hn
state_before: d m n : Nat
dgt1 : 1 < d
Hm : d ∣ m
Hn : d ∣ n
co : coprime m n
⊢ d ∣ gcd m n
Theorem: CauSeq.inf_eq_left
File: Mathlib/Data/Real/CauSeq.lean

tactic: simpa only [CauSeq.inf_comm] using CauSeq.inf_eq_right h
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b : CauSeq α abs
h : a ≤ b
⊢ a ⊓ b ≈ a
Theorem: minimals_mono
File: Mathlib/Order/Minimal.lean

tactic: have := eq_of_mem_minimals ha hb (h _ _ hab)
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
b : α
hb : b ∈ s
hab : r₁ b a
⊢ r₁ a b

tactic: subst this
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b✝ : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
b : α
hb : b ∈ s
hab : r₁ b a
this : a = b
⊢ r₁ a b

tactic: exact hab
state_before: α : Type u_1
r r₁ r₂ : α → α → Prop
s t : Set α
a✝ b : α
inst✝ : IsAntisymm α r₂
h : ∀ (a b : α), r₁ a b → r₂ a b
a : α
ha : a ∈ minimals r₂ s
hb : a ∈ s
hab : r₁ a a
⊢ r₁ a a
Theorem: Polynomial.natDegree_cyclotomic
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: rw [natDegree, degree_cyclotomic]
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ natDegree (cyclotomic n R) = Nat.totient n

tactic: norm_cast
state_before: n : ℕ
R : Type u_1
inst✝¹ : Ring R
inst✝ : Nontrivial R
⊢ WithBot.unbot' 0 ↑(Nat.totient n) = Nat.totient n
Theorem: CategoryTheory.Iso.refl_trans
File: Mathlib/CategoryTheory/Iso.lean

tactic: ext
state_before: C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
⊢ refl X ≪≫ α = α

tactic: apply Category.id_comp
state_before: case w
C : Type u
inst✝ : Category C
X Y Z : C
α : X ≅ Y
⊢ (refl X ≪≫ α).hom = α.hom
Theorem: HasDerivAt.rpow_const
File: Mathlib/Analysis/SpecialFunctions/Pow/Deriv.lean

tactic: rw [← hasDerivWithinAt_univ] at *
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivAt f f' x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) x

tactic: exact hf.rpow_const hx
state_before: f g : ℝ → ℝ
f' g' x y p : ℝ
s : Set ℝ
hf : HasDerivWithinAt f f' Set.univ x
hx : f x ≠ 0 ∨ 1 ≤ p
⊢ HasDerivWithinAt (fun y => f y ^ p) (f' * p * f x ^ (p - 1)) Set.univ x
Theorem: MvPowerSeries.coeff_X_pow
File: Mathlib/RingTheory/PowerSeries/Basic.lean

tactic: rw [X_pow_eq s n, coeff_monomial]
state_before: σ : Type u_1
R : Type u_2
inst✝¹ : Semiring R
inst✝ : DecidableEq σ
m : σ →₀ ℕ
s : σ
n : ℕ
⊢ ↑(coeff R m) (X s ^ n) = if m = single s n then 1 else 0
Theorem: Matrix.sub_mul
File: Mathlib/Data/Matrix/Basic.lean

tactic: rw [sub_eq_add_neg, Matrix.add_mul, Matrix.neg_mul, sub_eq_add_neg]
state_before: l : Type ?u.381155
m : Type u_1
n : Type u_2
o : Type u_3
m' : o → Type ?u.381169
n' : o → Type ?u.381174
R : Type ?u.381177
S : Type ?u.381180
α : Type v
β : Type w
γ : Type ?u.381187
inst✝¹ : NonUnitalNonAssocRing α
inst✝ : Fintype n
M M' : Matrix m n α
N : Matrix n o α
⊢ (M - M') ⬝ N = M ⬝ N - M' ⬝ N
Theorem: CategoryTheory.Limits.cokernelComparison_map_desc
File: Mathlib/CategoryTheory/Limits/Shapes/Kernels.lean

tactic: simp only [← G.map_comp, w, Functor.map_zero]
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ G.map f ≫ G.map h = 0

tactic: apply coequalizer.hom_ext
state_before: C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ cokernelComparison f G ≫ G.map (cokernel.desc f h w) = cokernel.desc (G.map f) (G.map h) (_ : G.map f ≫ G.map h = 0)

tactic: simp [← G.map_comp]
state_before: case h
C : Type u
inst✝⁶ : Category C
inst✝⁵ : HasZeroMorphisms C
X Y : C
f : X ⟶ Y
D : Type u₂
inst✝⁴ : Category D
inst✝³ : HasZeroMorphisms D
G : C ⥤ D
inst✝² : Functor.PreservesZeroMorphisms G
inst✝¹ : HasCokernel f
inst✝ : HasCokernel (G.map f)
Z : C
h : Y ⟶ Z
w : f ≫ h = 0
⊢ coequalizer.π (G.map f) 0 ≫ cokernelComparison f G ≫ G.map (cokernel.desc f h w) =
    coequalizer.π (G.map f) 0 ≫ cokernel.desc (G.map f) (G.map h) (_ : G.map f ≫ G.map h = 0)
Theorem: ENNReal.nat_cast_sub
File: Mathlib/Data/Real/ENNReal.lean

tactic: rw [← coe_nat, Nat.cast_tsub, coe_sub, coe_nat, coe_nat]
state_before: α : Type ?u.173725
β : Type ?u.173728
a b c d : ℝ≥0∞
r p q : ℝ≥0
m n : ℕ
⊢ ↑(m - n) = ↑m - ↑n
Theorem: Complex.ofReal_mul_re
File: Mathlib/Data/Complex/Basic.lean

tactic: simp [ofReal']
state_before: r : ℝ
z : ℂ
⊢ (↑r * z).re = r * z.re
Theorem: Nat.coprime_self_add_right
File: Mathlib/Data/Nat/GCD/Basic.lean

tactic: rw [add_comm, coprime_add_self_right]
state_before: m n : ℕ
⊢ coprime m (m + n) ↔ coprime m n
Theorem: List.append_cancel_right
File: src/lean/Init/Data/List/BasicAux.lean

tactic: match as, cs with
| [], []       => rfl
| [], c::cs    => have aux := congrArg length h; simp_arith at aux
| a::as, []    => have aux := congrArg length h; simp_arith at aux
| a::as, c::cs => injection h with h₁ h₂; subst h₁; rw [append_cancel_right h₂]
state_before: α : Type u_1
as bs cs : List α
h : as ++ bs = cs ++ bs
⊢ as = cs

tactic: rfl
state_before: α : Type u_1
as bs cs : List α
h : [] ++ bs = [] ++ bs
⊢ [] = []

tactic: have aux := congrArg length h
state_before: α : Type u_1
as bs cs✝ : List α
c : α
cs : List α
h : [] ++ bs = c :: cs ++ bs
⊢ [] = c :: cs

tactic: simp_arith at aux
state_before: α : Type u_1
as bs cs✝ : List α
c : α
cs : List α
h : [] ++ bs = c :: cs ++ bs
aux : length ([] ++ bs) = length (c :: cs ++ bs)
⊢ [] = c :: cs

tactic: have aux := congrArg length h
state_before: α : Type u_1
as✝ bs cs : List α
a : α
as : List α
h : a :: as ++ bs = [] ++ bs
⊢ a :: as = []

tactic: simp_arith at aux
state_before: α : Type u_1
as✝ bs cs : List α
a : α
as : List α
h : a :: as ++ bs = [] ++ bs
aux : length (a :: as ++ bs) = length ([] ++ bs)
⊢ a :: as = []

tactic: injection h with h₁ h₂
state_before: α : Type u_1
as✝ bs cs✝ : List α
a : α
as : List α
c : α
cs : List α
h : a :: as ++ bs = c :: cs ++ bs
⊢ a :: as = c :: cs

tactic: subst h₁
state_before: α : Type u_1
as✝ bs cs✝ : List α
a : α
as : List α
c : α
cs : List α
h₁ : a = c
h₂ : List.append as bs = List.append cs bs
⊢ a :: as = c :: cs

tactic: rw [append_cancel_right h₂]
state_before: α : Type u_1
as✝ bs cs✝ : List α
a : α
as cs : List α
h₂ : List.append as bs = List.append cs bs
⊢ a :: as = a :: cs
Theorem: Vector.nodup_iff_injective_get
File: Mathlib/Data/Vector/Basic.lean

tactic: cases' v with l hl
state_before: n : ℕ
α : Type u_1
v : Vector α n
⊢ List.Nodup (toList v) ↔ Function.Injective (get v)

tactic: subst hl
state_before: case mk
n : ℕ
α : Type u_1
l : List α
hl : List.length l = n
⊢ List.Nodup (toList { val := l, property := hl }) ↔ Function.Injective (get { val := l, property := hl })

tactic: exact List.nodup_iff_injective_get
state_before: case mk
α : Type u_1
l : List α
⊢ List.Nodup (toList { val := l, property := (_ : List.length l = List.length l) }) ↔
    Function.Injective (get { val := l, property := (_ : List.length l = List.length l) })
Theorem: Matrix.fromBlocks_one
File: Mathlib/Data/Matrix/Block.lean

tactic: ext (i j)
state_before: l : Type u_1
m : Type u_2
n : Type ?u.123200
o : Type ?u.123203
p : Type ?u.123206
q : Type ?u.123209
m' : o → Type ?u.123214
n' : o → Type ?u.123219
p' : o → Type ?u.123224
R : Type ?u.123227
S : Type ?u.123230
α : Type u_3
β : Type ?u.123236
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : Zero α
inst✝ : One α
⊢ fromBlocks 1 0 0 1 = 1

tactic: rcases i with ⟨⟩ <;> rcases j with ⟨⟩ <;> simp [one_apply]
state_before: case a.h
l : Type u_1
m : Type u_2
n : Type ?u.123200
o : Type ?u.123203
p : Type ?u.123206
q : Type ?u.123209
m' : o → Type ?u.123214
n' : o → Type ?u.123219
p' : o → Type ?u.123224
R : Type ?u.123227
S : Type ?u.123230
α : Type u_3
β : Type ?u.123236
inst✝³ : DecidableEq l
inst✝² : DecidableEq m
inst✝¹ : Zero α
inst✝ : One α
i j : l ⊕ m
⊢ fromBlocks 1 0 0 1 i j = OfNat.ofNat 1 i j
Theorem: Subgroup.map_comap_eq_self
File: Mathlib/GroupTheory/Subgroup/Basic.lean

tactic: rwa [map_comap_eq, inf_eq_right]
state_before: G : Type u_1
G' : Type ?u.569964
inst✝³ : Group G
inst✝² : Group G'
A : Type ?u.569973
inst✝¹ : AddGroup A
N : Type u_2
inst✝ : Group N
f✝ f : G →* N
H : Subgroup N
h : H ≤ range f
⊢ map f (comap f H) = H
Theorem: LocalHomeomorph.Set.EqOn.restr_eqOn_source
File: Mathlib/Topology/LocalHomeomorph.lean

tactic: constructor
state_before: α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ LocalHomeomorph.restr e e'.source ≈ LocalHomeomorph.restr e' e.source

tactic: rw [e'.restr_source' _ e.open_source]
state_before: case left
α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ (LocalHomeomorph.restr e e'.source).toLocalEquiv.source = (LocalHomeomorph.restr e' e.source).toLocalEquiv.source

tactic: rw [e.restr_source' _ e'.open_source]
state_before: case left
α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ (LocalHomeomorph.restr e e'.source).toLocalEquiv.source = e'.source ∩ e.source

tactic: exact Set.inter_comm _ _
state_before: case left
α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ e.source ∩ e'.source = e'.source ∩ e.source

tactic: rw [e.restr_source' _ e'.open_source]
state_before: case right
α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ EqOn (↑(LocalHomeomorph.restr e e'.source)) (↑(LocalHomeomorph.restr e' e.source))
    (LocalHomeomorph.restr e e'.source).toLocalEquiv.source

tactic: refine' (EqOn.trans _ h).trans _ <;> simp only [mfld_simps, eqOn_refl]
state_before: case right
α : Type u_1
β : Type u_2
γ : Type ?u.81218
δ : Type ?u.81221
inst✝³ : TopologicalSpace α
inst✝² : TopologicalSpace β
inst✝¹ : TopologicalSpace γ
inst✝ : TopologicalSpace δ
e✝ : LocalHomeomorph α β
e'✝ : LocalHomeomorph β γ
e e' : LocalHomeomorph α β
h : EqOn (↑e) (↑e') (e.source ∩ e'.source)
⊢ EqOn (↑(LocalHomeomorph.restr e e'.source)) (↑(LocalHomeomorph.restr e' e.source)) (e.source ∩ e'.source)
Theorem: MeasureTheory.IsFundamentalDomain.measure_eq
File: Mathlib/MeasureTheory/Group/FundamentalDomain.lean

tactic: simpa only [set_lintegral_one] using hs.set_lintegral_eq ht (fun _ => 1) fun _ _ => rfl
state_before: G : Type u_1
H : Type ?u.302877
α : Type u_2
β : Type ?u.302883
E : Type ?u.302886
inst✝¹⁰ : Group G
inst✝⁹ : Group H
inst✝⁸ : MulAction G α
inst✝⁷ : MeasurableSpace α
inst✝⁶ : MulAction H β
inst✝⁵ : MeasurableSpace β
inst✝⁴ : NormedAddCommGroup E
s t : Set α
μ : Measure α
inst✝³ : MeasurableSpace G
inst✝² : MeasurableSMul G α
inst✝¹ : SMulInvariantMeasure G α μ
inst✝ : Countable G
ν : Measure α
hs : IsFundamentalDomain G s
ht : IsFundamentalDomain G t
⊢ ↑↑μ s = ↑↑μ t
Theorem: NNRat.coe_eq_zero
File: Mathlib/Data/Rat/NNRat.lean

tactic: norm_cast
state_before: α : Type ?u.14941
p q : ℚ≥0
⊢ ↑q = 0 ↔ q = 0
Theorem: FractionalIdeal.map_div
File: Mathlib/RingTheory/FractionalIdeal.lean

tactic: by_cases H : J = 0
state_before: R : Type ?u.1232681
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1232888
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁶ : CommRing R₁
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J

tactic: rw [H, div_zero, map_zero, div_zero]
state_before: case pos
R : Type ?u.1232681
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1232888
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁶ : CommRing R₁
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
H : J = 0
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J

tactic: rw [← coeToSubmodule_inj, div_nonzero H, div_nonzero (map_ne_zero _ H)]
state_before: case neg
R : Type ?u.1232681
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1232888
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁶ : CommRing R₁
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
H : ¬J = 0
⊢ map (↑h) (I / J) = map (↑h) I / map (↑h) J

tactic: simp [Submodule.map_div]
state_before: case neg
R : Type ?u.1232681
inst✝⁹ : CommRing R
S : Submonoid R
P : Type ?u.1232888
inst✝⁸ : CommRing P
inst✝⁷ : Algebra R P
loc : IsLocalization S P
R₁ : Type u_1
inst✝⁶ : CommRing R₁
K : Type u_2
inst✝⁵ : Field K
inst✝⁴ : Algebra R₁ K
frac : IsFractionRing R₁ K
inst✝³ : IsDomain R₁
I✝ J✝ : FractionalIdeal R₁⁰ K
K' : Type u_3
inst✝² : Field K'
inst✝¹ : Algebra R₁ K'
inst✝ : IsFractionRing R₁ K'
I J : FractionalIdeal R₁⁰ K
h : K ≃ₐ[R₁] K'
H : ¬J = 0
⊢ ↑(map ↑h { val := ↑I / ↑J, property := (_ : IsFractional R₁⁰ (↑I / ↑J)) }) =
    ↑{ val := ↑(map (↑h) I) / ↑(map (↑h) J), property := (_ : IsFractional R₁⁰ (↑(map (↑h) I) / ↑(map (↑h) J))) }
Theorem: LinearMap.isNilpotent_mulLeft_iff
File: Mathlib/RingTheory/Nilpotent.lean

tactic: constructor <;> rintro ⟨n, hn⟩ <;> use n <;>
    simp only [mulLeft_eq_zero_iff, pow_mulLeft] at hn⊢ <;>
  exact hn
state_before: R S : Type u
x y : R
A : Type v
inst✝² : CommSemiring R
inst✝¹ : Semiring A
inst✝ : Algebra R A
a : A
⊢ IsNilpotent (mulLeft R a) ↔ IsNilpotent a
Theorem: List.length_of_sublistsLen
File: Mathlib/Data/List/Sublists.lean

tactic: simp_all
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
l l' : List α
h : l' ∈ sublistsLen 0 l
⊢ length l' = 0

tactic: rw [sublistsLen_succ_cons, mem_append, mem_map] at h
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) (a :: l)
⊢ length l' = n + 1

tactic: rcases h with (h | ⟨l', h, rfl⟩)
state_before: α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) l ∨ ∃ a_1, a_1 ∈ sublistsLen n l ∧ a :: a_1 = l'
⊢ length l' = n + 1

tactic: exact length_of_sublistsLen h
state_before: case inl
α✝ : Type u
β : Type v
γ : Type w
α : Type u_1
n : ℕ
a : α
l l' : List α
h : l' ∈ sublistsLen (n + 1) l
⊢ length l' = n + 1
Theorem: ENNReal.mul_sub
File: Mathlib/Data/Real/ENNReal.lean

tactic: simp only [mul_comm a]
state_before: α : Type ?u.198618
β : Type ?u.198621
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < c → c < b → a ≠ ⊤
⊢ a * (b - c) = a * b - a * c

tactic: exact sub_mul h
state_before: α : Type ?u.198618
β : Type ?u.198621
a b c d : ℝ≥0∞
r p q : ℝ≥0
h : 0 < c → c < b → a ≠ ⊤
⊢ (b - c) * a = b * a - c * a
Theorem: div_le_one'
File: Mathlib/Algebra/Order/Group/Defs.lean

tactic: rw [← mul_le_mul_iff_right b, one_mul, div_eq_mul_inv, inv_mul_cancel_right]
state_before: α : Type u
inst✝² : Group α
inst✝¹ : LE α
inst✝ : CovariantClass α α (swap fun x x_1 => x * x_1) fun x x_1 => x ≤ x_1
a b c d : α
⊢ a / b ≤ 1 ↔ a ≤ b
Theorem: Nat.pred_eq_ppred
File: Mathlib/Data/Nat/PSub.lean

tactic: cases n <;> rfl
state_before: n : ℕ
⊢ pred n = Option.getD (ppred n) 0
Theorem: Real.log_one
File: Mathlib/Analysis/SpecialFunctions/Log/Basic.lean

tactic: rw [exp_log zero_lt_one, exp_zero]
state_before: x y : ℝ
⊢ exp (log 1) = exp 0