1337xyz1337xyz/leandojo-benchmark4-v10 huggingface dataset:
Theorem: Finset.mulDysonETransform.card
File: Mathlib/Combinatorics/Additive/ETransform.lean

tactic: dsimp
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (mulDysonETransform e x).1.card + (mulDysonETransform e x).2.card = x.1.card + x.2.card
state_after: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card

tactic: rw [← card_smul_finset e (_ ∩ _), smul_finset_inter, smul_inv_smul, inter_comm,
  card_union_add_card_inter, card_smul_finset]
state_before: α : Type u_1
inst✝¹ : DecidableEq α
inst✝ : CommGroup α
e : α
x : Finset α × Finset α
⊢ (x.1 ∪ e • x.2).card + (x.2 ∩ e⁻¹ • x.1).card = x.1.card + x.2.card
state_after: no goals
Theorem: MeasureTheory.union_ae_eq_left_iff_ae_subset
File: Mathlib/MeasureTheory/Measure/MeasureSpace.lean

tactic: rw [ae_le_set]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᶠ[ae μ] s ↔ t ≤ᶠ[ae μ] s
state_after: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᶠ[ae μ] s ↔ μ (t \ s) = 0

tactic: refine
  ⟨fun h => by simpa only [union_diff_left] using (ae_eq_set.mp h).1, fun h =>
    eventuallyLE_antisymm_iff.mpr
      ⟨by rwa [ae_le_set, union_diff_left],
        HasSubset.Subset.eventuallyLE subset_union_left⟩⟩
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
⊢ s ∪ t =ᶠ[ae μ] s ↔ μ (t \ s) = 0
state_after: no goals

tactic: simpa only [union_diff_left] using (ae_eq_set.mp h).1
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : s ∪ t =ᶠ[ae μ] s
⊢ μ (t \ s) = 0
state_after: no goals

tactic: rwa [ae_le_set, union_diff_left]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
δ : Type u_4
ι : Type u_5
R : Type u_6
R' : Type u_7
m : MeasurableSpace α
μ μ₁ μ₂ : Measure α
s s₁ s₂ t : Set α
h : μ (t \ s) = 0
⊢ s ∪ t ≤ᶠ[ae μ] s
state_after: no goals
Theorem: rec_heq_iff_heq
File: Mathlib/Logic/Basic.lean

tactic: subst e
state_before: α : Sort u_2
a : α
β : Sort u_1
b : α
C : α → Sort u_1
x : C a
y : β
e : a = b
⊢ HEq (e ▸ x) y ↔ HEq x y
state_after: α : Sort u_2
a : α
β : Sort u_1
C : α → Sort u_1
x : C a
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y

tactic: rfl
state_before: α : Sort u_2
a : α
β : Sort u_1
C : α → Sort u_1
x : C a
y : β
⊢ HEq (⋯ ▸ x) y ↔ HEq x y
state_after: no goals
Theorem: inducing_prod_const
File: Mathlib/Topology/Constructions.lean

tactic: simp_rw [inducing_iff, instTopologicalSpaceProd, induced_inf, induced_compose, Function.comp,
  induced_const, inf_top_eq]
state_before: X : Type u
Y : Type v
Z : Type u_1
W : Type u_2
ε : Type u_3
ζ : Type u_4
inst✝⁵ : TopologicalSpace X
inst✝⁴ : TopologicalSpace Y
inst✝³ : TopologicalSpace Z
inst✝² : TopologicalSpace W
inst✝¹ : TopologicalSpace ε
inst✝ : TopologicalSpace ζ
y : Y
f : X → Z
⊢ (Inducing fun x => (f x, y)) ↔ Inducing f
state_after: no goals
Theorem: MulAction.continuousSMul_compHom
File: Mathlib/Topology/Algebra/MulAction.lean

tactic: let _ : MulAction N X := MulAction.compHom _ f
state_before: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : Monoid M
inst✝³ : MulAction M X
inst✝² : ContinuousSMul M X
N : Type u_5
inst✝¹ : TopologicalSpace N
inst✝ : Monoid N
f : N →* M
hf : Continuous ⇑f
⊢ ContinuousSMul N X
state_after: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : Monoid M
inst✝³ : MulAction M X
inst✝² : ContinuousSMul M X
N : Type u_5
inst✝¹ : TopologicalSpace N
inst✝ : Monoid N
f : N →* M
hf : Continuous ⇑f
x✝ : MulAction N X := compHom X f
⊢ ContinuousSMul N X

tactic: exact ⟨(hf.comp continuous_fst).smul continuous_snd⟩
state_before: M : Type u_1
X : Type u_2
Y : Type u_3
α : Type u_4
inst✝⁷ : TopologicalSpace M
inst✝⁶ : TopologicalSpace X
inst✝⁵ : TopologicalSpace Y
inst✝⁴ : Monoid M
inst✝³ : MulAction M X
inst✝² : ContinuousSMul M X
N : Type u_5
inst✝¹ : TopologicalSpace N
inst✝ : Monoid N
f : N →* M
hf : Continuous ⇑f
x✝ : MulAction N X := compHom X f
⊢ ContinuousSMul N X
state_after: no goals
Theorem: Polynomial.prod_cyclotomic'_eq_X_pow_sub_one
File: Mathlib/RingTheory/Polynomial/Cyclotomic/Basic.lean

tactic: classical
have hd : (n.divisors : Set ℕ).PairwiseDisjoint fun k => primitiveRoots k K :=
  fun x _ y _ hne => IsPrimitiveRoot.disjoint hne
simp only [X_pow_sub_one_eq_prod hpos h, cyclotomic', ← Finset.prod_biUnion hd,
  h.nthRoots_one_eq_biUnion_primitiveRoots]
state_before: K✝ : Type u_1
inst✝² : Field K✝
K : Type u_2
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
⊢ ∏ i ∈ n.divisors, cyclotomic' i K = X ^ n - 1
state_after: no goals

tactic: have hd : (n.divisors : Set ℕ).PairwiseDisjoint fun k => primitiveRoots k K :=
  fun x _ y _ hne => IsPrimitiveRoot.disjoint hne
state_before: K✝ : Type u_1
inst✝² : Field K✝
K : Type u_2
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
⊢ ∏ i ∈ n.divisors, cyclotomic' i K = X ^ n - 1
state_after: K✝ : Type u_1
inst✝² : Field K✝
K : Type u_2
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
hd : (↑n.divisors).PairwiseDisjoint fun k => primitiveRoots k K
⊢ ∏ i ∈ n.divisors, cyclotomic' i K = X ^ n - 1

tactic: simp only [X_pow_sub_one_eq_prod hpos h, cyclotomic', ← Finset.prod_biUnion hd,
  h.nthRoots_one_eq_biUnion_primitiveRoots]
state_before: K✝ : Type u_1
inst✝² : Field K✝
K : Type u_2
inst✝¹ : CommRing K
inst✝ : IsDomain K
ζ : K
n : ℕ
hpos : 0 < n
h : IsPrimitiveRoot ζ n
hd : (↑n.divisors).PairwiseDisjoint fun k => primitiveRoots k K
⊢ ∏ i ∈ n.divisors, cyclotomic' i K = X ^ n - 1
state_after: no goals
Theorem: LieModule.coe_maxTrivLinearMapEquivLieModuleHom
File: Mathlib/Algebra/Lie/Abelian.lean

tactic: ext
state_before: R : Type u
L : Type v
M : Type w
N : Type w₁
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✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : ↥(maxTrivSubmodule R L (M →ₗ[R] N))
⊢ ⇑(maxTrivLinearMapEquivLieModuleHom f) = ⇑↑f
state_after: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
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✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : ↥(maxTrivSubmodule R L (M →ₗ[R] N))
x✝ : M
⊢ (maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑f x✝

tactic: rfl
state_before: case h
R : Type u
L : Type v
M : Type w
N : Type w₁
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✝³ : AddCommGroup N
inst✝² : Module R N
inst✝¹ : LieRingModule L N
inst✝ : LieModule R L N
f : ↥(maxTrivSubmodule R L (M →ₗ[R] N))
x✝ : M
⊢ (maxTrivLinearMapEquivLieModuleHom f) x✝ = ↑f x✝
state_after: no goals
Theorem: lineDifferentiableWithinAt_smul_iff
File: Mathlib/Analysis/Calculus/LineDeriv/Basic.lean

tactic: simpa [smul_smul, inv_mul_cancel hc] using h.smul (c ⁻¹)
state_before: 𝕜 : Type u_1
inst✝⁴ : NontriviallyNormedField 𝕜
F : Type u_2
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
E : Type u_3
inst✝¹ : AddCommGroup E
inst✝ : Module 𝕜 E
f : E → F
s : Set E
x v : E
f' : F
c : 𝕜
hc : c ≠ 0
h : LineDifferentiableWithinAt 𝕜 f s x (c • v)
⊢ LineDifferentiableWithinAt 𝕜 f s x v
state_after: no goals
Theorem: Function.Periodic.sub_period
File: Mathlib/Algebra/Periodic.lean

tactic: rw [sub_eq_add_neg, ← add_assoc, h2.neg, h1]
state_before: α : Type u_1
β : Type u_2
γ : Type u_3
f g : α → β
c c₁ c₂ x✝ : α
inst✝ : AddGroup α
h1 : Periodic f c₁
h2 : Periodic f c₂
x : α
⊢ f (x + (c₁ - c₂)) = f x
state_after: no goals
Theorem: bernoulli'_spec
File: Mathlib/NumberTheory/Bernoulli.lean

tactic: rw [sum_range_succ_comm, bernoulli'_def n, tsub_self, choose_zero_right, sub_self, zero_add,
  div_one, cast_one, one_mul, sub_add, ← sum_sub_distrib, ← sub_eq_zero, sub_sub_cancel_left,
  neg_eq_zero]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ k ∈ range n.succ, ↑(n.choose (n - k)) / (↑n - ↑k + 1) * bernoulli' k = 1
state_after: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ range n, (↑(n.choose x) / (↑n - ↑x + 1) * bernoulli' x - ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x) = 0

tactic: exact Finset.sum_eq_zero (fun x hx => by rw [choose_symm (le_of_lt (mem_range.1 hx)), sub_self])
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n : ℕ
⊢ ∑ x ∈ range n, (↑(n.choose x) / (↑n - ↑x + 1) * bernoulli' x - ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x) = 0
state_after: no goals

tactic: rw [choose_symm (le_of_lt (mem_range.1 hx)), sub_self]
state_before: A : Type u_1
inst✝¹ : CommRing A
inst✝ : Algebra ℚ A
n x : ℕ
hx : x ∈ range n
⊢ ↑(n.choose x) / (↑n - ↑x + 1) * bernoulli' x - ↑(n.choose (n - x)) / (↑n - ↑x + 1) * bernoulli' x = 0
state_after: no goals
Theorem: Sublattice.map_inf
File: Mathlib/Order/Sublattice.lean

tactic: rw [← SetLike.coe_set_eq]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L✝ M✝ : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
L M : Sublattice α
f : LatticeHom α β
hf : Injective ⇑f
⊢ map f (L ⊓ M) = map f L ⊓ map f M
state_after: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L✝ M✝ : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
L M : Sublattice α
f : LatticeHom α β
hf : Injective ⇑f
⊢ ↑(map f (L ⊓ M)) = ↑(map f L ⊓ map f M)

tactic: simp [Set.image_inter hf]
state_before: ι : Sort u_1
α : Type u_2
β : Type u_3
γ : Type u_4
inst✝² : Lattice α
inst✝¹ : Lattice β
inst✝ : Lattice γ
L✝ M✝ : Sublattice α
f✝ : LatticeHom α β
s t : Set α
a : α
L M : Sublattice α
f : LatticeHom α β
hf : Injective ⇑f
⊢ ↑(map f (L ⊓ M)) = ↑(map f L ⊓ map f M)
state_after: no goals
Theorem: CategoryTheory.Limits.coprod.map_id_comp
File: Mathlib/CategoryTheory/Limits/Shapes/BinaryProducts.lean

tactic: simp
state_before: C : Type u
inst✝³ : Category.{v, u} C
X✝ Y✝ X Y Z W : C
f : X ⟶ Y
g : Y ⟶ Z
inst✝² : HasBinaryCoproduct W X
inst✝¹ : HasBinaryCoproduct W Y
inst✝ : HasBinaryCoproduct W Z
⊢ map (𝟙 W) (f ≫ g) = map (𝟙 W) f ≫ map (𝟙 W) g
state_after: no goals
Theorem: LinearMap.tailing_sup_tunnel_succ_le_tunnel
File: Mathlib/LinearAlgebra/Prod.lean

tactic: dsimp [tailing, tunnel, tunnel', tunnelAux]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ f.tailing i n ⊔ OrderDual.ofDual ((f.tunnel i) (n + 1)) ≤ OrderDual.ofDual ((f.tunnel i) n)
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Submodule.map (((f.tunnel' i n).fst.subtype ∘ₗ ↑(f.tunnel' i n).snd.symm) ∘ₗ f) (Submodule.snd R M N) ⊔
      Submodule.map (((f.tunnel' i n).fst.subtype ∘ₗ ↑(f.tunnel' i n).snd.symm) ∘ₗ f) (Submodule.fst R M N) ≤
    (f.tunnel' i n).fst

tactic: erw [← Submodule.map_sup, sup_comm, Submodule.fst_sup_snd, Submodule.map_comp, Submodule.map_comp]
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Submodule.map (((f.tunnel' i n).fst.subtype ∘ₗ ↑(f.tunnel' i n).snd.symm) ∘ₗ f) (Submodule.snd R M N) ⊔
      Submodule.map (((f.tunnel' i n).fst.subtype ∘ₗ ↑(f.tunnel' i n).snd.symm) ∘ₗ f) (Submodule.fst R M N) ≤
    (f.tunnel' i n).fst
state_after: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Submodule.map (f.tunnel' i n).fst.subtype (Submodule.map (↑(f.tunnel' i n).snd.symm) (Submodule.map f ⊤)) ≤
    (f.tunnel' i n).fst

tactic: apply Submodule.map_subtype_le
state_before: R : Type u
K : Type u'
M : Type v
V : Type v'
M₂ : Type w
V₂ : Type w'
M₃ : Type y
V₃ : Type y'
M₄ : Type z
ι : Type x
M₅ : Type u_1
M₆ : Type u_2
inst✝⁴ : Ring R
N : Type u_3
inst✝³ : AddCommGroup M
inst✝² : Module R M
inst✝¹ : AddCommGroup N
inst✝ : Module R N
f : M × N →ₗ[R] M
i : Injective ⇑f
n : ℕ
⊢ Submodule.map (f.tunnel' i n).fst.subtype (Submodule.map (↑(f.tunnel' i n).snd.symm) (Submodule.map f ⊤)) ≤
    (f.tunnel' i n).fst
state_after: no goals
Theorem: Nat.squarefree_two
File: Mathlib/Data/Nat/Squarefree.lean

tactic: rw [squarefree_iff_nodup_factors] <;> simp
state_before: s : Finset ℕ
m n p : ℕ
⊢ Squarefree 2
state_after: no goals
Theorem: SimpleGraph.Walk.bypass_isPath
File: Mathlib/Combinatorics/SimpleGraph/Connectivity.lean

tactic: simp!
state_before: case nil
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ : V
⊢ nil.bypass.IsPath
state_after: no goals

tactic: simp only [bypass]
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
⊢ (cons h✝ p').bypass.IsPath
state_after: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
⊢ (if hs : u✝ ∈ p'.bypass.support then p'.bypass.dropUntil u✝ hs else cons h✝ p'.bypass).IsPath

tactic: split_ifs with hs
state_before: case cons
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
⊢ (if hs : u✝ ∈ p'.bypass.support then p'.bypass.dropUntil u✝ hs else cons h✝ p'.bypass).IsPath
state_after: case pos
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
hs : u✝ ∈ p'.bypass.support
⊢ (p'.bypass.dropUntil u✝ hs).IsPath

case neg
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
hs : u✝ ∉ p'.bypass.support
⊢ (cons h✝ p'.bypass).IsPath

tactic: exact ih.dropUntil hs
state_before: case pos
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
hs : u✝ ∈ p'.bypass.support
⊢ (p'.bypass.dropUntil u✝ hs).IsPath
state_after: no goals

tactic: simp [*, cons_isPath_iff]
state_before: case neg
V : Type u
V' : Type v
V'' : Type w
G : SimpleGraph V
G' : SimpleGraph V'
G'' : SimpleGraph V''
inst✝ : DecidableEq V
u v u✝ v✝ w✝ : V
h✝ : G.Adj u✝ v✝
p' : G.Walk v✝ w✝
ih : p'.bypass.IsPath
hs : u✝ ∉ p'.bypass.support
⊢ (cons h✝ p'.bypass).IsPath
state_after: no goals
Theorem: lowerSemicontinuousWithinAt_univ_iff
File: Mathlib/Topology/Semicontinuous.lean

tactic: simp [LowerSemicontinuousWithinAt, LowerSemicontinuousAt, nhdsWithin_univ]
state_before: α : Type u_1
inst✝¹ : TopologicalSpace α
β : Type u_2
inst✝ : Preorder β
f g : α → β
x : α
s t : Set α
y z : β
⊢ LowerSemicontinuousWithinAt f univ x ↔ LowerSemicontinuousAt f x
state_after: no goals
Theorem: MeasurableSpace.measurableSingletonClass_of_countablySeparated
File: Mathlib/MeasureTheory/MeasurableSpace/CountablyGenerated.lean

tactic: rcases measurable_injection_nat_bool_of_countablySeparated α with ⟨f, fmeas, finj⟩
state_before: α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
⊢ MeasurableSingletonClass α
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
⊢ MeasurableSingletonClass α

tactic: refine ⟨fun x ↦ ?_⟩
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
⊢ MeasurableSingletonClass α
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
x : α
⊢ MeasurableSet {x}

tactic: rw [← finj.preimage_image {x}, image_singleton]
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
x : α
⊢ MeasurableSet {x}
state_after: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
x : α
⊢ MeasurableSet (f ⁻¹' {f x})

tactic: exact fmeas $ MeasurableSet.singleton _
state_before: case intro.intro
α : Type u_1
β : Type u_2
inst✝¹ : MeasurableSpace α
inst✝ : CountablySeparated α
f : α → ℕ → Bool
fmeas : Measurable f
finj : Injective f
x : α
⊢ MeasurableSet (f ⁻¹' {f x})
state_after: no goals
Theorem: Filter.map_eq_of_inverse
File: Mathlib/Order/Filter/Basic.lean

tactic: refine le_antisymm hφ (le_trans ?_ (map_mono hψ))
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ map φ f = g
state_after: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ g ≤ map φ (map ψ g)

tactic: rw [map_map, eq, map_id]
state_before: α : Type u
β : Type v
γ : Type w
δ : Type u_1
ι : Sort x
l f : Filter α
g : Filter β
φ : α → β
ψ : β → α
eq : φ ∘ ψ = id
hφ : Tendsto φ f g
hψ : Tendsto ψ g f
⊢ g ≤ map φ (map ψ g)
state_after: no goals
Theorem: AnalyticOn.continuous
File: Mathlib/Analysis/Analytic/Basic.lean

tactic: rw [continuous_iff_continuousOn_univ]
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
f : E → F
fa : AnalyticOn 𝕜 f univ
⊢ Continuous f
state_after: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
f : E → F
fa : AnalyticOn 𝕜 f univ
⊢ ContinuousOn f univ

tactic: exact fa.continuousOn
state_before: 𝕜 : Type u_1
E : Type u_2
F : Type u_3
G : Type u_4
inst✝⁶ : NontriviallyNormedField 𝕜
inst✝⁵ : NormedAddCommGroup E
inst✝⁴ : NormedSpace 𝕜 E
inst✝³ : NormedAddCommGroup F
inst✝² : NormedSpace 𝕜 F
inst✝¹ : NormedAddCommGroup G
inst✝ : NormedSpace 𝕜 G
f✝ g : E → F
p pf pg : FormalMultilinearSeries 𝕜 E F
x : E
r r' : ℝ≥0∞
f : E → F
fa : AnalyticOn 𝕜 f univ
⊢ ContinuousOn f univ
state_after: no goals
Theorem: Mathlib.Tactic.Peel.and_imp_left_of_imp_imp
File: Mathlib/Tactic/Peel.lean

tactic: tauto
state_before: p q r : Prop
h : r → p → q
⊢ r ∧ p → r ∧ q
state_after: no goals
Theorem: StrictMono.sign_comp
File: Mathlib/Data/Sign.lean

tactic: simp only [sign_apply, ← map_zero f, hf.lt_iff_lt]
state_before: α : Type u_1
inst✝⁶ : Zero α
inst✝⁵ : LinearOrder α
a✝ : α
β : Type u_2
F : Type u_3
inst✝⁴ : Zero β
inst✝³ : Preorder β
inst✝² : DecidableRel fun x x_1 => x < x_1
inst✝¹ : FunLike F α β
inst✝ : ZeroHomClass F α β
f : F
hf : StrictMono ⇑f
a : α
⊢ sign (f a) = sign a
state_after: no goals
Theorem: FirstOrder.Language.BoundedFormula.realize_liftAt_one_self
File: Mathlib/ModelTheory/Semantics.lean

tactic: rw [realize_liftAt_one (refl n), iff_eq_eq]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + 1) → M
⊢ (liftAt 1 n φ).Realize v xs ↔ φ.Realize v (xs ∘ castSucc)
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + 1) → M
⊢ φ.Realize v (xs ∘ fun i => if ↑i < n then i.castSucc else i.succ) = φ.Realize v (xs ∘ castSucc)

tactic: refine congr rfl (congr rfl (funext fun i => ?_))
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + 1) → M
⊢ φ.Realize v (xs ∘ fun i => if ↑i < n then i.castSucc else i.succ) = φ.Realize v (xs ∘ castSucc)
state_after: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + 1) → M
i : Fin n
⊢ (if ↑i < n then i.castSucc else i.succ) = i.castSucc

tactic: rw [if_pos i.is_lt]
state_before: L : Language
L' : Language
M : Type w
N : Type u_1
P : Type u_2
inst✝² : L.Structure M
inst✝¹ : L.Structure N
inst✝ : L.Structure P
α : Type u'
β : Type v'
γ : Type u_3
n✝ l : ℕ
φ✝ ψ : L.BoundedFormula α l
θ : L.BoundedFormula α l.succ
v✝ : α → M
xs✝ : Fin l → M
n : ℕ
φ : L.BoundedFormula α n
v : α → M
xs : Fin (n + 1) → M
i : Fin n
⊢ (if ↑i < n then i.castSucc else i.succ) = i.castSucc
state_after: no goals
Theorem: Composition.mem_range_embedding
File: Mathlib/Combinatorics/Enumerative/Composition.lean

tactic: have : c.embedding (c.index j) (c.invEmbedding j) ∈ Set.range (c.embedding (c.index j)) :=
  Set.mem_range_self _
state_before: n : ℕ
c : Composition n
j : Fin n
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))
state_after: n : ℕ
c : Composition n
j : Fin n
this : (c.embedding (c.index j)) (c.invEmbedding j) ∈ Set.range ⇑(c.embedding (c.index j))
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))

tactic: rwa [c.embedding_comp_inv j] at this
state_before: n : ℕ
c : Composition n
j : Fin n
this : (c.embedding (c.index j)) (c.invEmbedding j) ∈ Set.range ⇑(c.embedding (c.index j))
⊢ j ∈ Set.range ⇑(c.embedding (c.index j))
state_after: no goals