tasksource/leandojo huggingface dataset:
Theorem: Nat.cast_add_one_ne_zero
File: Mathlib/Algebra/CharZero/Defs.lean

tactic: norm_cast
state_before: R : Type u_1
inst✝¹ : AddMonoidWithOne R
inst✝ : CharZero R
n : ℕ
⊢ ↑n + 1 ≠ 0

tactic: exact n.succ_ne_zero
state_before: R : Type u_1
inst✝¹ : AddMonoidWithOne R
inst✝ : CharZero R
n : ℕ
⊢ ¬n + 1 = 0
Theorem: Int.le_sub_right_of_add_le
File: Std/Data/Int/Lemmas.lean

tactic: have h := Int.add_le_add_right h (-b)
state_before: a b c : Int
h : a + b ≤ c
⊢ a ≤ c - b

tactic: rwa [Int.add_neg_cancel_right] at h
state_before: a b c : Int
h✝ : a + b ≤ c
h : a + b + -b ≤ c + -b
⊢ a ≤ c - b
Theorem: Matrix.det_updateColumn_add_smul_self
File: Mathlib/LinearAlgebra/Matrix/Determinant.lean

tactic: rw [← det_transpose, ← updateRow_transpose, ← det_transpose A]
state_before: m : Type ?u.1700808
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ det (updateColumn A i fun k => A k i + c • A k j) = det A

tactic: exact det_updateRow_add_smul_self Aᵀ hij c
state_before: m : Type ?u.1700808
n : Type u_1
inst✝⁴ : DecidableEq n
inst✝³ : Fintype n
inst✝² : DecidableEq m
inst✝¹ : Fintype m
R : Type v
inst✝ : CommRing R
A : Matrix n n R
i j : n
hij : i ≠ j
c : R
⊢ det (updateRow Aᵀ i fun k => A k i + c • A k j) = det Aᵀ
Theorem: Summable.comp_injective
File: Mathlib/Topology/Algebra/InfiniteSum/Basic.lean

tactic: simpa only [Set.indicator_range_comp] using
  (hi.summable_iff (fun x hx => Set.indicator_of_not_mem hx _)).2 (hf.indicator (Set.range i))
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type ?u.755506
inst✝³ : AddCommGroup α
inst✝² : UniformSpace α
inst✝¹ : UniformAddGroup α
f g : β → α
a a₁ a₂ : α
inst✝ : CompleteSpace α
i : γ → β
hf : Summable f
hi : Injective i
⊢ Summable (f ∘ i)
Theorem: card_le_of_injective
File: Mathlib/LinearAlgebra/InvariantBasisNumber.lean

tactic: let P := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
⊢ Fintype.card α ≤ Fintype.card β

tactic: let Q := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
⊢ Fintype.card α ≤ Fintype.card β

tactic: exact
  le_of_fin_injective R ((Q.symm.toLinearMap.comp f).comp P.toLinearMap)
    (((LinearEquiv.symm Q).injective.comp i).comp (LinearEquiv.injective P))
state_before: R : Type u
inst✝³ : Semiring R
inst✝² : StrongRankCondition R
α : Type u_1
β : Type u_2
inst✝¹ : Fintype α
inst✝ : Fintype β
f : (α → R) →ₗ[R] β → R
i : Injective ↑f
P : (Fin (Fintype.card α) → R) ≃ₗ[R] α → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin α)
Q : (Fin (Fintype.card β) → R) ≃ₗ[R] β → R := LinearEquiv.funCongrLeft R R (Fintype.equivFin β)
⊢ Fintype.card α ≤ Fintype.card β
Theorem: Int.units_pow_eq_pow_mod_two
File: Mathlib/Data/Int/Order/Units.lean

tactic: conv =>
    lhs
    rw [← Nat.mod_add_div n 2];
    rw [pow_add, pow_mul, units_sq, one_pow, mul_one]
state_before: u : ℤˣ
n : ℕ
⊢ u ^ n = u ^ (n % 2)
Theorem: funext
File: src/lean/Init/Core.lean

tactic: let eqv (f g : (x : α) → β x) := ∀ x, f x = g x
state_before: a b c d : Prop
α✝ : Type u
r : α✝ → α✝ → Prop
α : Sort u
β : α → Sort v
f g : (x : α) → β x
h : ∀ (x : α), f x = g x
⊢ f = g

tactic: let extfunApp (f : Quot eqv) (x : α) : β x :=
  Quot.liftOn f
    (fun (f : ∀ (x : α), β x) => f x)
    (fun _ _ h => h x)
state_before: a b c d : Prop
α✝ : Type u
r : α✝ → α✝ → Prop
α : Sort u
β : α → Sort v
f g : (x : α) → β x
h : ∀ (x : α), f x = g x
eqv : ((x : α) → β x) → ((x : α) → β x) → Prop := fun f g => ∀ (x : α), f x = g x
⊢ f = g

tactic: show extfunApp (Quot.mk eqv f) = extfunApp (Quot.mk eqv g)
state_before: a b c d : Prop
α✝ : Type u
r : α✝ → α✝ → Prop
α : Sort u
β : α → Sort v
f g : (x : α) → β x
h : ∀ (x : α), f x = g x
eqv : ((x : α) → β x) → ((x : α) → β x) → Prop := fun f g => ∀ (x : α), f x = g x
extfunApp : Quot eqv → (x : α) → β x :=
  fun f x => Quot.liftOn f (fun f => f x) (_ : ∀ (x_1 x_2 : (x : α) → β x), eqv x_1 x_2 → x_1 x = x_2 x)
⊢ f = g

tactic: exact congrArg extfunApp (Quot.sound h)
state_before: a b c d : Prop
α✝ : Type u
r : α✝ → α✝ → Prop
α : Sort u
β : α → Sort v
f g : (x : α) → β x
h : ∀ (x : α), f x = g x
eqv : ((x : α) → β x) → ((x : α) → β x) → Prop := fun f g => ∀ (x : α), f x = g x
extfunApp : Quot eqv → (x : α) → β x :=
  fun f x => Quot.liftOn f (fun f => f x) (_ : ∀ (x_1 x_2 : (x : α) → β x), eqv x_1 x_2 → x_1 x = x_2 x)
⊢ extfunApp (Quot.mk eqv f) = extfunApp (Quot.mk eqv g)
Theorem: zpow_two_pos_of_ne_zero
File: Mathlib/Algebra/Order/Field/Power.lean

tactic: convert zpow_bit0_pos h 1
state_before: α : Type u_1
inst✝ : LinearOrderedField α
a b c d : α
n : ℤ
h : a ≠ 0
⊢ 0 < a ^ 2
Theorem: Complex.isCauSeq_conj
File: Mathlib/Data/Complex/Basic.lean

tactic: rw [← RingHom.map_sub, abs_conj]
state_before: f : CauSeq ℂ ↑abs
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → ↑abs (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ ↑abs ((fun n => ↑(starRingEnd ℂ) (↑f n)) j - (fun n => ↑(starRingEnd ℂ) (↑f n)) i) < ε

tactic: exact hi j hj
state_before: f : CauSeq ℂ ↑abs
ε : ℝ
ε0 : ε > 0
i : ℕ
hi : ∀ (j : ℕ), j ≥ i → ↑abs (↑f j - ↑f i) < ε
j : ℕ
hj : j ≥ i
⊢ ↑abs (↑f j - ↑f i) < ε
Theorem: FiniteDimensional.finrank_linearMap
File: Mathlib/LinearAlgebra/FreeModule/Finite/Matrix.lean

tactic: classical
  letI := nontrivial_of_invariantBasisNumber R
  have h := LinearMap.toMatrix (chooseBasis R M) (chooseBasis R N)
  simp_rw [h.finrank_eq, FiniteDimensional.finrank_matrix,
    FiniteDimensional.finrank_eq_card_chooseBasisIndex, mul_comm]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommRing R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
⊢ finrank R (M →ₗ[R] N) = finrank R M * finrank R N

tactic: letI := nontrivial_of_invariantBasisNumber R
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommRing R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
⊢ finrank R (M →ₗ[R] N) = finrank R M * finrank R N

tactic: have h := LinearMap.toMatrix (chooseBasis R M) (chooseBasis R N)
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommRing R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
⊢ finrank R (M →ₗ[R] N) = finrank R M * finrank R N

tactic: simp_rw [h.finrank_eq, FiniteDimensional.finrank_matrix,
  FiniteDimensional.finrank_eq_card_chooseBasisIndex, mul_comm]
state_before: R : Type u
M : Type v
N : Type w
inst✝⁹ : CommRing R
inst✝⁸ : StrongRankCondition R
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : Module.Free R M
inst✝⁴ : Module.Finite R M
inst✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : Module.Free R N
inst✝ : Module.Finite R N
this : Nontrivial R := nontrivial_of_invariantBasisNumber R
h : (M →ₗ[R] N) ≃ₗ[R] Matrix (Module.Free.ChooseBasisIndex R N) (Module.Free.ChooseBasisIndex R M) R
⊢ finrank R (M →ₗ[R] N) = finrank R M * finrank R N
Theorem: wcovby_iff_covby_or_eq
File: Mathlib/Order/Cover.lean

tactic: rw [le_antisymm_iff, wcovby_iff_covby_or_le_and_le]
state_before: α : Type u_1
β : Type ?u.36173
inst✝ : PartialOrder α
a b c : α
⊢ a ⩿ b ↔ a ⋖ b ∨ a = b
Theorem: Metric.thickening_eq_biUnion_ball
File: Mathlib/Topology/MetricSpace/HausdorffDistance.lean

tactic: ext x
state_before: ι : Sort ?u.96949
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
⊢ thickening δ E = ⋃ (x : X) (_ : x ∈ E), ball x δ

tactic: simp only [mem_iUnion₂, exists_prop]
state_before: case h
ι : Sort ?u.96949
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
x : X
⊢ x ∈ thickening δ E ↔ x ∈ ⋃ (x : X) (_ : x ∈ E), ball x δ

tactic: exact mem_thickening_iff
state_before: case h
ι : Sort ?u.96949
α : Type u
β : Type v
inst✝¹ : PseudoEMetricSpace α
δ✝ : ℝ
s : Set α
x✝ : α
X : Type u
inst✝ : PseudoMetricSpace X
δ : ℝ
E : Set X
x : X
⊢ x ∈ thickening δ E ↔ ∃ i, i ∈ E ∧ x ∈ ball i δ
Theorem: Equiv.refl_trans
File: Mathlib/Logic/Equiv/Defs.lean

tactic: cases e
state_before: α : Sort u
β : Sort v
γ : Sort w
e : α ≃ β
⊢ (Equiv.refl α).trans e = e

tactic: rfl
state_before: case mk
α : Sort u
β : Sort v
γ : Sort w
toFun✝ : α → β
invFun✝ : β → α
left_inv✝ : LeftInverse invFun✝ toFun✝
right_inv✝ : Function.RightInverse invFun✝ toFun✝
⊢ (Equiv.refl α).trans { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ } =
    { toFun := toFun✝, invFun := invFun✝, left_inv := left_inv✝, right_inv := right_inv✝ }
Theorem: nonempty_frontier_iff
File: Mathlib/Topology/Connected.lean

tactic: simp only [nonempty_iff_ne_empty, Ne.def, frontier_eq_empty_iff, not_or]
state_before: α : Type u
β : Type v
ι : Type ?u.71012
π : ι → Type ?u.71017
inst✝¹ : TopologicalSpace α
s✝ t u v : Set α
inst✝ : PreconnectedSpace α
s : Set α
⊢ Set.Nonempty (frontier s) ↔ Set.Nonempty s ∧ s ≠ univ
Theorem: Localization.mk_eq_mk_iff'
File: Mathlib/GroupTheory/MonoidLocalization.lean

tactic: have : Nonempty s := One.nonempty
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ : { x // x ∈ s }
⊢ mk a₁ a₂ = mk b₁ b₂ ↔ ↑b₂ * a₁ = ↑a₂ * b₁

tactic: simp_rw [mk_eq_mk_iff, r_iff_exists, mul_left_cancel_iff, exists_const]
state_before: α : Type u_1
inst✝ : CancelCommMonoid α
s : Submonoid α
a₁ b₁ : α
a₂ b₂ : { x // x ∈ s }
this : Nonempty { x // x ∈ s }
⊢ mk a₁ a₂ = mk b₁ b₂ ↔ ↑b₂ * a₁ = ↑a₂ * b₁
Theorem: MvPFunctor.comp_wPathCasesOn
File: Mathlib/Data/PFunctor/Multivariate/W.lean

tactic: ext (i x)
state_before: n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : TypeVec n
h : α ⟹ β
a : P.A
f : PFunctor.B (last P) a → PFunctor.W (last P)
g' : B (drop P) a ⟹ α
g : (j : PFunctor.B (last P) a) → WPath P (f j) ⟹ α
⊢ h ⊚ wPathCasesOn P g' g = wPathCasesOn P (h ⊚ g') fun i => h ⊚ g i

tactic: cases x <;> rfl
state_before: case a.h
n : ℕ
P : MvPFunctor (n + 1)
α : TypeVec n
β : TypeVec n
h : α ⟹ β
a : P.A
f : PFunctor.B (last P) a → PFunctor.W (last P)
g' : B (drop P) a ⟹ α
g : (j : PFunctor.B (last P) a) → WPath P (f j) ⟹ α
i : Fin2 n
x : WPath P (WType.mk a fun j => f j) i
⊢ (h ⊚ wPathCasesOn P g' g) i x = wPathCasesOn P (h ⊚ g') (fun i => h ⊚ g i) i x
Theorem: CategoryTheory.MonoidalCategory.leftUnitor_inv_tensor_id
File: Mathlib/CategoryTheory/Monoidal/CoherenceLemmas.lean

tactic: coherence
state_before: C : Type u_2
inst✝¹ : Category C
inst✝ : MonoidalCategory C
X Y : C
⊢ (λ_ X).inv ⊗ 𝟙 Y = (λ_ (X ⊗ Y)).inv ≫ (α_ tensorUnit' X Y).inv
Theorem: Nat.eq_of_factorization_eq
File: Mathlib/Data/Nat/Factorization/Basic.lean

tactic: simpa only [List.perm_iff_count, factors_count_eq] using h
state_before: a b : ℕ
ha : a ≠ 0
hb : b ≠ 0
h : ∀ (p : ℕ), ↑(factorization a) p = ↑(factorization b) p
⊢ factors a ~ factors b
Theorem: Basis.abs_det_adjustToOrientation
File: Mathlib/LinearAlgebra/Orientation.lean

tactic: cases' e.det_adjustToOrientation x with h h <;> simp [h]
state_before: R : Type u_1
inst✝⁶ : LinearOrderedCommRing R
M : Type u_3
inst✝⁵ : AddCommGroup M
inst✝⁴ : Module R M
ι : Type u_2
inst✝³ : Fintype ι
inst✝² : DecidableEq ι
inst✝¹ : Nontrivial R
inst✝ : Nonempty ι
e : Basis ι R M
x : Orientation R M ι
v : ι → M
⊢ abs (↑(det (adjustToOrientation e x)) v) = abs (↑(det e) v)
Theorem: Affine.Simplex.reindex_range_points
File: Mathlib/LinearAlgebra/AffineSpace/Independent.lean

tactic: rw [reindex, Set.range_comp, Equiv.range_eq_univ, Set.image_univ]
state_before: k : Type u_1
V : Type u_2
P : Type u_3
inst✝³ : Ring k
inst✝² : AddCommGroup V
inst✝¹ : Module k V
inst✝ : AffineSpace V P
m n : ℕ
s : Simplex k P m
e : Fin (m + 1) ≃ Fin (n + 1)
⊢ Set.range (reindex s e).points = Set.range s.points
Theorem: Std.RBNode.Stream.forIn_eq_forIn_toList
File: Std/Data/RBMap/Lemmas.lean

tactic: simp [forIn, RBNode.forIn]
state_before: m : Type u_1 → Type u_2
α : Type u_3
α✝ : Type u_1
init : α✝
f : α → α✝ → m (ForInStep α✝)
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ forIn t init f = forIn (RBNode.toList t) init f

tactic: rw [List.forIn_eq_bindList, forIn_visit_eq_bindList]
state_before: m : Type u_1 → Type u_2
α : Type u_3
α✝ : Type u_1
init : α✝
f : α → α✝ → m (ForInStep α✝)
inst✝¹ : Monad m
inst✝ : LawfulMonad m
t : RBNode α
⊢ ForInStep.run <$> forIn.visit f t init = forIn (RBNode.toList t) init f
Theorem: Ordnode.all_rotateL
File: Mathlib/Data/Ordmap/Ordset.lean

tactic: cases r <;> simp [rotateL, all_node']
state_before: α : Type u_1
P : α → Prop
l : Ordnode α
x : α
r : Ordnode α
⊢ All P (rotateL l x r) ↔ All P l ∧ P x ∧ All P r

tactic: split_ifs <;>
simp [all_node3L, all_node4L, All, and_assoc]
state_before: case node
α : Type u_1
P : α → Prop
l : Ordnode α
x : α
size✝ : ℕ
l✝ : Ordnode α
x✝ : α
r✝ : Ordnode α
⊢ All P (if size l✝ < ratio * size r✝ then node3L l x l✝ x✝ r✝ else node4L l x l✝ x✝ r✝) ↔
    All P l ∧ P x ∧ All P (node size✝ l✝ x✝ r✝)
Theorem: Equiv.injective_pointReflection_left_of_injective_bit0
File: Mathlib/Algebra/AddTorsor.lean

tactic: rwa [pointReflection_apply, pointReflection_apply, vadd_eq_vadd_iff_sub_eq_vsub,
  vsub_sub_vsub_cancel_right, ← neg_vsub_eq_vsub_rev, neg_eq_iff_add_eq_zero, ← bit0, ← bit0_zero,
  h.eq_iff, vsub_eq_zero_iff_eq] at hy
state_before: G✝ : Type ?u.56742
P✝ : Type ?u.56745
inst✝³ : AddGroup G✝
inst✝² : AddTorsor G✝ P✝
G : Type u_1
P : Type u_2
inst✝¹ : AddCommGroup G
inst✝ : AddTorsor G P
h : Injective bit0
y x₁ x₂ : P
hy : ↑(pointReflection x₁) y = ↑(pointReflection x₂) y
⊢ x₁ = x₂
Theorem: Asymptotics.isBigOWith_iff
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: rw [IsBigOWith_def]
state_before: α : Type u_1
β : Type ?u.1884
E : Type u_2
F : Type u_3
G : Type ?u.1893
E' : Type ?u.1896
F' : Type ?u.1899
G' : Type ?u.1902
E'' : Type ?u.1905
F'' : Type ?u.1908
G'' : Type ?u.1911
R : Type ?u.1914
R' : Type ?u.1917
𝕜 : Type ?u.1920
𝕜' : Type ?u.1923
inst✝¹² : Norm E
inst✝¹¹ : Norm F
inst✝¹⁰ : Norm G
inst✝⁹ : SeminormedAddCommGroup E'
inst✝⁸ : SeminormedAddCommGroup F'
inst✝⁷ : SeminormedAddCommGroup G'
inst✝⁶ : NormedAddCommGroup E''
inst✝⁵ : NormedAddCommGroup F''
inst✝⁴ : NormedAddCommGroup G''
inst✝³ : SeminormedRing R
inst✝² : SeminormedRing R'
inst✝¹ : NormedField 𝕜
inst✝ : NormedField 𝕜'
c c' c₁ c₂ : ℝ
f : α → E
g : α → F
k : α → G
f' : α → E'
g' : α → F'
k' : α → G'
f'' : α → E''
g'' : α → F''
k'' : α → G''
l l' : Filter α
⊢ IsBigOWith c l f g ↔ ∀ᶠ (x : α) in l, ‖f x‖ ≤ c * ‖g x‖
Theorem: LieHom.ker_eq_bot
File: Mathlib/Algebra/Lie/Submodule.lean

tactic: rw [← LieSubmodule.coe_toSubmodule_eq_iff, ker_coeSubmodule, LieSubmodule.bot_coeSubmodule,
  LinearMap.ker_eq_bot, coe_toLinearMap]
state_before: R : Type u
L : Type v
L' : Type w₂
M : Type w
M' : Type w₁
inst✝¹² : CommRing R
inst✝¹¹ : LieRing L
inst✝¹⁰ : LieAlgebra R L
inst✝⁹ : LieRing L'
inst✝⁸ : LieAlgebra R L'
inst✝⁷ : AddCommGroup M
inst✝⁶ : Module R M
inst✝⁵ : LieRingModule L M
inst✝⁴ : LieModule R L M
inst✝³ : AddCommGroup M'
inst✝² : Module R M'
inst✝¹ : LieRingModule L M'
inst✝ : LieModule R L M'
f : L →ₗ⁅R⁆ L'
I : LieIdeal R L
J : LieIdeal R L'
⊢ ker f = ⊥ ↔ Function.Injective ↑f
Theorem: Trivialization.toPretrivialization_injective
File: Mathlib/Topology/FiberBundle/Trivialization.lean

tactic: ext1
state_before: ι : Type ?u.21592
B : Type u_1
F : Type u_2
E : B → Type ?u.21603
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
e e' : Trivialization F proj
h : (fun e => toPretrivialization e) e = (fun e => toPretrivialization e) e'
⊢ e = e'

tactic: exacts [LocalHomeomorph.toLocalEquiv_injective (congr_arg Pretrivialization.toLocalEquiv h),
  congr_arg Pretrivialization.baseSet h]
state_before: case h₁
ι : Type ?u.21592
B : Type u_1
F : Type u_2
E : B → Type ?u.21603
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
e e' : Trivialization F proj
h : (fun e => toPretrivialization e) e = (fun e => toPretrivialization e) e'
⊢ e.toLocalHomeomorph = e'.toLocalHomeomorph

case h₂
ι : Type ?u.21592
B : Type u_1
F : Type u_2
E : B → Type ?u.21603
Z : Type u_3
inst✝³ : TopologicalSpace B
inst✝² : TopologicalSpace F
proj : Z → B
inst✝¹ : TopologicalSpace Z
inst✝ : TopologicalSpace (TotalSpace E)
e✝ : Trivialization F proj
x : Z
e e' : Trivialization F proj
h : (fun e => toPretrivialization e) e = (fun e => toPretrivialization e) e'
⊢ e.baseSet = e'.baseSet
Theorem: continuousMul_iInf
File: Mathlib/Topology/Algebra/Monoid.lean

tactic: rw [← sInf_range]
state_before: ι : Type ?u.456770
α : Type ?u.456773
X : Type ?u.456776
M : Type u_1
N : Type ?u.456782
inst✝¹ : TopologicalSpace X
ι' : Sort u_2
inst✝ : Mul M
ts : ι' → TopologicalSpace M
h' : ∀ (i : ι'), ContinuousMul M
⊢ ContinuousMul M

tactic: exact continuousMul_sInf (Set.forall_range_iff.mpr h')
state_before: ι : Type ?u.456770
α : Type ?u.456773
X : Type ?u.456776
M : Type u_1
N : Type ?u.456782
inst✝¹ : TopologicalSpace X
ι' : Sort u_2
inst✝ : Mul M
ts : ι' → TopologicalSpace M
h' : ∀ (i : ι'), ContinuousMul M
⊢ ContinuousMul M
Theorem: Fin.pred_succAbove_pred
File: Mathlib/Data/Fin/Basic.lean

tactic: obtain hbelow | habove := lt_or_le (castSucc b) a
state_before: n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
⊢ ↑(succAbove (pred a ha)) (pred b hb) = pred (↑(succAbove a) b) hk

tactic: rw [Fin.succAbove_below]
state_before: case inl
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
hbelow : ↑castSucc b < a
⊢ ↑(succAbove (pred a ha)) (pred b hb) = pred (↑(succAbove a) b) hk

tactic: rwa [castSucc_pred_eq_pred_castSucc, Fin.pred_inj, Fin.succAbove_below]
state_before: case inl
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
hbelow : ↑castSucc b < a
⊢ ↑castSucc (pred b hb) = pred (↑(succAbove a) b) hk

tactic: rwa [castSucc_pred_eq_pred_castSucc, pred_lt_pred_iff]
state_before: case inl.h
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
hbelow : ↑castSucc b < a
⊢ ↑castSucc (pred b hb) < pred a ha

tactic: rw [Fin.succAbove_above]
state_before: case inr
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
⊢ ↑(succAbove (pred a ha)) (pred b hb) = pred (↑(succAbove a) b) hk

tactic: have : (b.pred hb).succ = b.succ.pred (Fin.succ_ne_zero _) := by rw [succ_pred, pred_succ]
state_before: case inr
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
⊢ succ (pred b hb) = pred (↑(succAbove a) b) hk

case inr.h
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
⊢ pred a ha ≤ ↑castSucc (pred b hb)

tactic: rw [succ_pred, pred_succ]
state_before: n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
⊢ succ (pred b hb) = pred (succ b) (_ : succ b ≠ 0)

tactic: rwa [this, Fin.pred_inj, Fin.succAbove_above]
state_before: case inr
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
this : succ (pred b hb) = pred (succ b) (_ : succ b ≠ 0)
⊢ succ (pred b hb) = pred (↑(succAbove a) b) hk

tactic: rwa [castSucc_pred_eq_pred_castSucc, Fin.pred_le_pred_iff]
state_before: case inr.h
n m : ℕ
a : Fin (n + 2)
b : Fin (n + 1)
ha : a ≠ 0
hb : b ≠ 0
hk : optParam (↑(succAbove a) b ≠ 0) (_ : ↑(succAbove a) b ≠ 0)
habove : a ≤ ↑castSucc b
⊢ pred a ha ≤ ↑castSucc (pred b hb)
Theorem: Nat.bit1_inj
File: Mathlib/Init/Data/Nat/Lemmas.lean

tactic: simp [Nat.bit1_eq_succ_bit0] at h
state_before: n m : ℕ
h : bit1 n = bit1 m
⊢ succ (bit0 n) = succ (bit0 m)

tactic: rw [h]
state_before: n m : ℕ
h : bit0 n = bit0 m
⊢ succ (bit0 n) = succ (bit0 m)

tactic: injection this
state_before: n m : ℕ
h : bit1 n = bit1 m
this : succ (bit0 n) = succ (bit0 m)
⊢ bit0 n = bit0 m
Theorem: Homeomorph.isBigO_congr
File: Mathlib/Analysis/Asymptotics/Asymptotics.lean

tactic: simp only [IsBigO_def]
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 : α ≃ₜ β
b : β
f : β → E
g : β → F
⊢ f =O[𝓝 b] g ↔ (f ∘ ↑e) =O[𝓝 (↑(Homeomorph.symm e) b)] (g ∘ ↑e)

tactic: exact exists_congr fun C => e.isBigOWith_congr
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 : α ≃ₜ β
b : β
f : β → E
g : β → F
⊢ (∃ c, IsBigOWith c (𝓝 b) f g) ↔ ∃ c, IsBigOWith c (𝓝 (↑(Homeomorph.symm e) b)) (f ∘ ↑e) (g ∘ ↑e)
Theorem: MvPolynomial.isWeightedHomogeneous_monomial
File: Mathlib/RingTheory/MvPolynomial/WeightedHomogeneous.lean

tactic: intro c hc
state_before: R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
⊢ IsWeightedHomogeneous w (↑(monomial d) r) m

tactic: rw [coeff_monomial] at hc
state_before: R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
c : σ →₀ ℕ
hc : coeff c (↑(monomial d) r) ≠ 0
⊢ ↑(weightedDegree' w) c = m

tactic: split_ifs at hc with h
state_before: R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
hc : (if d = c then r else 0) ≠ 0
⊢ ↑(weightedDegree' w) c = m

tactic: subst c
state_before: case inl
R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
h : d = c
hc : r ≠ 0
⊢ ↑(weightedDegree' w) c = m

tactic: exact hm
state_before: case inl
R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
hc✝ : r ≠ 0
hc : coeff d (↑(monomial d) r) ≠ 0
⊢ ↑(weightedDegree' w) d = m

tactic: contradiction
state_before: case inr
R : Type u_3
M : Type u_2
inst✝¹ : CommSemiring R
σ : Type u_1
inst✝ : AddCommMonoid M
w : σ → M
d : σ →₀ ℕ
r : R
m : M
hm : ↑(weightedDegree' w) d = m
c : σ →₀ ℕ
hc✝ : coeff c (↑(monomial d) r) ≠ 0
h : ¬d = c
hc : 0 ≠ 0
⊢ ↑(weightedDegree' w) c = m