diff --git a/docs/src/guide/derivative.md b/docs/src/guide/derivative.md
index c8b11dca..8e6a342d 100644
--- a/docs/src/guide/derivative.md
+++ b/docs/src/guide/derivative.md
@@ -1,6 +1,6 @@
 ```@meta
 DocTestFilters = [r"≥|>=", r" == | = ", r" ∈ | in ", r" for all | ∀ ", r"d|∂", 
-                  r"integral|∫", r".*scalar_parameters.jl:813"]
+                  r"integral|∫", r".*scalar_parameters.jl:807"]
 ```
 
 # [Derivative Operators](@id deriv_docs)
@@ -509,7 +509,7 @@ julia> derivative_constraints(d1)
 
 julia> add_supports(t, 0.2)
 ┌ Warning: Support/method changes will invalidate existing derivative evaluation constraints that have been added to the InfiniteModel. Thus, these are being deleted.
-└ @ InfiniteOpt ~/work/infiniteopt/InfiniteOpt.jl/src/scalar_parameters.jl:813
+└ @ InfiniteOpt ~/work/infiniteopt/InfiniteOpt.jl/src/scalar_parameters.jl:807
 
 julia> has_derivative_constraints(d1)
 false
diff --git a/docs/src/manual/expression.md b/docs/src/manual/expression.md
index 4b54c352..c53a2bcf 100644
--- a/docs/src/manual/expression.md
+++ b/docs/src/manual/expression.md
@@ -193,6 +193,4 @@ InfiniteOpt._constraint_dependencies
 InfiniteOpt._constraint_dependencies(::GeneralVariableRef)
 InfiniteOpt._derivative_constraint_dependencies
 InfiniteOpt._derivative_constraint_dependencies(::GeneralVariableRef)
-InfiniteOpt._parameter_number
-InfiniteOpt._parameter_number(::GeneralVariableRef)
 ```
diff --git a/src/TranscriptionOpt/measures.jl b/src/TranscriptionOpt/measures.jl
index 2310c4c8..29fe7cae 100644
--- a/src/TranscriptionOpt/measures.jl
+++ b/src/TranscriptionOpt/measures.jl
@@ -82,8 +82,12 @@ function InfiniteOpt.add_semi_infinite_variable(
             InfiniteOpt.SemiInfiniteVariableIndex
         )
         push!(semi_infinite_vars, var)
-        ivref_param_nums = InfiniteOpt._parameter_numbers(ivref)
-        param_nums = var.parameter_nums
+        ivref_pref_supp_idxs = data.infvar_param_idxs[ivref]
+        pref_supp_idxs = [
+            ivref_pref_supp_idxs[i] 
+            for i in eachindex(ivref_pref_supp_idxs) 
+            if isnan(eval_supp[i])
+        ]
         supp_indices = support_index_iterator(backend, var.group_int_idxs)
         if ivref.index_type == InfiniteOpt.ParameterFunctionIndex && 
            !data.update_parameter_functions
@@ -95,9 +99,9 @@ function InfiniteOpt.add_semi_infinite_variable(
         sizehint!(lookup_dict, length(supp_indices))
         for i in supp_indices
             raw_supp = index_to_support(backend, i)
-            ivref_supp = [isnan(s) ? raw_supp[ivref_param_nums[j]] : s 
+            ivref_supp = [isnan(s) ? raw_supp[ivref_pref_supp_idxs[j]] : s 
                           for (j, s) in enumerate(eval_supp)]
-            supp = raw_supp[param_nums]
+            supp = raw_supp[pref_supp_idxs]
             lookup_dict[supp] = lookup_by_support(ivref, backend, ivref_supp)
         end
         if val_type == JuMP.VariableRef
@@ -106,6 +110,7 @@ function InfiniteOpt.add_semi_infinite_variable(
             data.pfunc_lookup[rvref] = lookup_dict
         end
         data.semi_lookup[(ivref, eval_supp)] = rvref
+        data.infvar_param_idxs[rvref] = pref_supp_idxs
         return rvref
     end
 end
diff --git a/src/TranscriptionOpt/model.jl b/src/TranscriptionOpt/model.jl
index c6f77dc5..b6195d19 100644
--- a/src/TranscriptionOpt/model.jl
+++ b/src/TranscriptionOpt/model.jl
@@ -24,6 +24,7 @@ mutable struct TranscriptionData
 
     # Metadata
     valid_indices::Dict{Any, Array{Bool}}
+    infvar_param_idxs::Dict{InfiniteOpt.GeneralVariableRef, Vector{Int}}
 
     # Internal variables (created via internal measure expansions)
     semi_infinite_vars::Vector{InfiniteOpt.SemiInfiniteVariable{InfiniteOpt.GeneralVariableRef}}
@@ -45,6 +46,7 @@ mutable struct TranscriptionData
     # Collected Supports
     supports::Tuple
     support_labels::Tuple
+    param_to_support_idx::Dict{InfiniteOpt.GeneralVariableRef, Int}
     has_internal_supports::Bool
 
     # Default constructor
@@ -61,6 +63,7 @@ mutable struct TranscriptionData
             Dict{InfiniteOpt.GeneralVariableRef, Float64}(),
             # meta data
             Dict{Any, Array{Bool}}(),
+            Dict{InfiniteOpt.GeneralVariableRef, Vector{Int}}(),
             # internal variables
             Vector{InfiniteOpt.SemiInfiniteVariable{InfiniteOpt.GeneralVariableRef}}(),
             Dict{Tuple{InfiniteOpt.GeneralVariableRef, Vector{Float64}}, InfiniteOpt.GeneralVariableRef}(),
@@ -76,6 +79,7 @@ mutable struct TranscriptionData
             # support storage
             (), 
             (), 
+            Dict{InfiniteOpt.GeneralVariableRef, Int}(),
             false,
             )
     end
@@ -90,6 +94,7 @@ function Base.empty!(data::TranscriptionData)
     empty!(data.pfunc_lookup)
     empty!(data.point_pfunc_mappings)
     empty!(data.valid_indices)
+    empty!(data.infvar_param_idxs)
     empty!(data.semi_infinite_vars)
     empty!(data.semi_lookup)
     data.last_point_index = 0
@@ -101,6 +106,7 @@ function Base.empty!(data::TranscriptionData)
     empty!(data.constr_supports)
     data.supports = ()
     data.support_labels = ()
+    empty!(data.param_to_support_idx)
     data.has_internal_supports = false
     return data
 end
diff --git a/src/TranscriptionOpt/transcribe.jl b/src/TranscriptionOpt/transcribe.jl
index 3a04f22f..6dae77c0 100644
--- a/src/TranscriptionOpt/transcribe.jl
+++ b/src/TranscriptionOpt/transcribe.jl
@@ -48,6 +48,13 @@ function set_parameter_supports(
     end for (i, group) in enumerate(prefs))
     data.supports = supps
     data.support_labels = labels
+    # Add the paramter index mapping
+    vt_prefs = InfiniteOpt.Collections.VectorTuple(prefs)
+    idx = 1
+    for p in vt_prefs
+        data.param_to_support_idx[p] = idx
+        idx += 1
+    end
     return
 end
 
@@ -110,8 +117,8 @@ end
 const _MaxNumParamsForPrinting = 4
 
 # Make variable name with infinite parameters values directly if possible
-function _make_var_name(base_name, param_nums, tuple_supp, var_idx)
-    if length(param_nums) <= _MaxNumParamsForPrinting
+function _make_var_name(base_name, pref_supp_idxs, tuple_supp, var_idx)
+    if length(pref_supp_idxs) <= _MaxNumParamsForPrinting
         return string(base_name, "(", join(tuple_supp, ", "), ")")
     else
         return string(base_name, "[", join(var_idx, ", "), "]")
@@ -141,10 +148,10 @@ function transcribe_parameter_functions!(
         # get the basic parameter function information
         pf = object.func
         base_name = object.name
-        param_nums = pf.parameter_nums
         group_idxs = pf.group_int_idxs
         prefs = pf.parameter_refs
         data = transcription_data(backend)
+        pref_supp_idxs = Int[data.param_to_support_idx[p] for p in prefs]
         # prepare for iterating over its supports
         supp_indices = support_index_iterator(backend, group_idxs)
         dims = size(supp_indices)[group_idxs]
@@ -155,12 +162,12 @@ function transcribe_parameter_functions!(
         lookup_dict = sizehint!(Dict{Vector{Float64}, val_type}(), length(vrefs))
         # Create a parameter for each support
         for i in supp_indices
-            supp = index_to_support(backend, i)[param_nums]
+            supp = index_to_support(backend, i)[pref_supp_idxs]
             var_idx = i.I[group_idxs]
             tuple_supp = Tuple(supp, prefs)
             p_value = pf(tuple_supp...)
             if data.update_parameter_functions
-                p_name = _make_var_name(base_name, param_nums, tuple_supp, var_idx)
+                p_name = _make_var_name(base_name, pref_supp_idxs, tuple_supp, var_idx)
                 jump_pref = JuMP.@variable(
                     backend.model,
                     base_name = p_name,
@@ -182,6 +189,7 @@ function transcribe_parameter_functions!(
         end
         data.infvar_mappings[pfref] = vrefs
         data.infvar_supports[pfref] = supps
+        data.infvar_param_idxs[pfref] = pref_supp_idxs
     end
     return
 end
@@ -217,9 +225,11 @@ end
 
 # Helper function for transcribing infinite variables/derivatives
 function _transcribe_infinite_variable(backend, vref, base_name, info)
-    param_nums = InfiniteOpt._parameter_numbers(vref)
+    # basic information
     group_idxs = InfiniteOpt.parameter_group_int_indices(vref)
     prefs = InfiniteOpt.raw_parameter_refs(vref)
+    data = transcription_data(backend)
+    pref_supp_idxs = Int[data.param_to_support_idx[p] for p in prefs]
     # prepare for iterating over its supports
     supp_indices = support_index_iterator(backend, group_idxs)
     dims = size(supp_indices)[group_idxs]
@@ -229,11 +239,11 @@ function _transcribe_infinite_variable(backend, vref, base_name, info)
     lookup_dict = sizehint!(Dict{Vector{Float64}, JuMP.VariableRef}(), length(vrefs))
     # create a variable for each support
     for i in supp_indices
-        supp = index_to_support(backend, i)[param_nums]
+        supp = index_to_support(backend, i)[pref_supp_idxs]
         new_info = _format_infinite_info(info, supp)
         var_idx = i.I[group_idxs]
         tuple_supp = Tuple(supp, prefs)
-        name = _make_var_name(base_name, param_nums, tuple_supp, var_idx)
+        name = _make_var_name(base_name, pref_supp_idxs, tuple_supp, var_idx)
         var = JuMP.ScalarVariable(new_info)
         jump_vref = JuMP.add_variable(backend.model, var, name)
         @inbounds vrefs[var_idx...] = jump_vref
@@ -241,11 +251,11 @@ function _transcribe_infinite_variable(backend, vref, base_name, info)
         @inbounds supps[var_idx...] = tuple_supp
     end
     # save the transcription information
-    data = transcription_data(backend)
     gvref = InfiniteOpt.GeneralVariableRef(vref)
     data.infvar_lookup[gvref] = lookup_dict
     data.infvar_mappings[gvref] = vrefs
     data.infvar_supports[gvref] = supps
+    data.infvar_param_idxs[gvref] = pref_supp_idxs
     return
 end
 
@@ -379,11 +389,12 @@ function transcribe_semi_infinite_variables!(
         rvref = InfiniteOpt.GeneralVariableRef(model, idx)
         # setup the mappings
         ivref = var.infinite_variable_ref
-        param_nums = var.parameter_nums
-        ivref_param_nums = InfiniteOpt._parameter_numbers(ivref)
         eval_supp = var.eval_support
         group_idxs = var.group_int_idxs
         prefs = InfiniteOpt.raw_parameter_refs(var)
+        data = transcription_data(backend)
+        pref_supp_idxs = Int[data.param_to_support_idx[p] for p in prefs]
+        ivref_pref_supp_idxs = data.infvar_param_idxs[ivref]
         # prepare for iterating over its supports
         data = transcription_data(backend)
         supp_indices = support_index_iterator(backend, group_idxs)
@@ -403,8 +414,8 @@ function transcribe_semi_infinite_variables!(
             raw_supp = index_to_support(backend, i)
             var_idx = i.I[group_idxs]
             # map to the current transcription variable
-            supp = raw_supp[param_nums]
-            ivref_supp = [isnan(s) ? raw_supp[ivref_param_nums[j]] : s
+            supp = raw_supp[pref_supp_idxs]
+            ivref_supp = [isnan(s) ? raw_supp[ivref_pref_supp_idxs[j]] : s
                           for (j, s) in enumerate(eval_supp)]
             jump_vref = lookup_by_support(ivref, backend, ivref_supp)
             @inbounds vrefs[var_idx...] = jump_vref
@@ -421,6 +432,7 @@ function transcribe_semi_infinite_variables!(
         else
             data.pfunc_lookup[rvref] = lookup_dict
         end
+        data.infvar_param_idxs[rvref] = pref_supp_idxs
     end
     return
 end
@@ -499,20 +511,15 @@ function transcription_expression(
     index_type::Type{V},
     backend::TranscriptionBackend,
     support::Vector{Float64}
-    ) where {V <: Union{InfVarIndex, InfiniteOpt.ParameterFunctionIndex, InfiniteOpt.MeasureIndex}}
-    param_nums = InfiniteOpt._parameter_numbers(vref)
-    return lookup_by_support(vref, index_type, backend, support[param_nums])
-end
-
-# Semi-Infinite variables
-function transcription_expression(
-    vref::InfiniteOpt.GeneralVariableRef,
-    index_type::Type{InfiniteOpt.SemiInfiniteVariableIndex},
-    backend::TranscriptionBackend,
-    support::Vector{Float64}
-    )
-    param_nums = InfiniteOpt._parameter_numbers(vref)
-    return lookup_by_support(vref, index_type, backend, support[param_nums])
+    ) where {V <: Union{
+        InfVarIndex, 
+        InfiniteOpt.ParameterFunctionIndex, 
+        InfiniteOpt.MeasureIndex, 
+        InfiniteOpt.SemiInfiniteVariableIndex}
+    }
+    data = transcription_data(backend)
+    pref_supp_idxs = data.infvar_param_idxs[vref]
+    return lookup_by_support(vref, index_type, backend, support[pref_supp_idxs])
 end
 
 # Point variables, finite variables and finite parameters
@@ -532,8 +539,8 @@ function transcription_expression(
     backend::TranscriptionBackend,
     support::Vector{Float64}
     ) where {V <: InfiniteOpt.InfiniteParameterIndex}
-    param_num = InfiniteOpt._parameter_number(vref)
-    return support[param_num]
+    data = transcription_data(backend)
+    return support[data.param_to_support_idx[vref]]
 end
 
 # AffExpr and QuadExpr and NonlinearExpr
@@ -544,7 +551,8 @@ function transcription_expression(
     )
     return InfiniteOpt.map_expression(
         v -> transcription_expression(v, backend, support), 
-        expr)
+        expr
+    )
 end
 
 # Real Number 
@@ -584,6 +592,8 @@ function transcribe_measures!(
         group_idxs = meas.group_int_idxs
         mref = InfiniteOpt.GeneralVariableRef(model, idx)
         prefs = InfiniteOpt.raw_parameter_refs(mref)
+        data = transcription_data(backend)
+        pref_supp_idxs = Int[data.param_to_support_idx[p] for p in prefs]
         # expand the measure
         if meas.constant_func
             new_expr = InfiniteOpt.analytic_expansion(meas.func, meas.data, backend)
@@ -602,15 +612,15 @@ function transcribe_measures!(
             raw_supp = index_to_support(backend, i)
             expr_idx = i.I[group_idxs]
             @inbounds exprs[expr_idx...] = transcription_expression(new_expr, backend, raw_supp)
-            supp = raw_supp[meas.parameter_nums]
+            supp = raw_supp[pref_supp_idxs]
             lookup_dict[supp] = lin_idx
             @inbounds supps[expr_idx...] = Tuple(supp, prefs)
         end
         # save the transcription information
-        data = transcription_data(backend)
         data.measure_lookup[mref] = lookup_dict
         data.measure_mappings[mref] = exprs
         data.measure_supports[mref] = supps
+        data.infvar_param_idxs[mref] = pref_supp_idxs
     end
     return
 end
@@ -698,13 +708,19 @@ function _get_info_constr_from_var(
     return JuMP.is_integer(trans_vref) ? JuMP.IntegerRef(trans_vref) : nothing
 end
 
+# Get the parameter support indexing for a restriction
+function _pref_supp_idxs(constr::InfiniteOpt.DomainRestrictedConstraint, data)
+    prefs = constr.restriction.parameter_refs
+    return [data.param_to_support_idx[p] for p in prefs]
+end
+_pref_supp_idxs(constr, data) = Int[]
+
 # Determine if a given raw support satisfies constraint domain restrictions
 function _support_in_restrictions(
     constr::InfiniteOpt.DomainRestrictedConstraint,
     support::Vector{Float64}
     )
-    restriction = constr.restriction
-    return restriction(support[restriction.parameter_nums])
+    return constr.restriction(support)
 end
 function _support_in_restrictions(
     constr::JuMP.AbstractConstraint,
@@ -799,6 +815,7 @@ function transcribe_constraints!(
         set = JuMP.moi_set(constr)
         group_idxs = object.group_int_idxs
         cref = InfiniteOpt.InfOptConstraintRef(model, idx)
+        data = transcription_data(backend)
         # prepare the iteration helpers
         supp_indices = support_index_iterator(backend, group_idxs)
         dims = size(supp_indices)[group_idxs]
@@ -825,11 +842,12 @@ function transcribe_constraints!(
         else
             # get basic setup information
             name = object.name
+            pref_supp_idxs = _pref_supp_idxs(constr, data)
             for i in supp_indices
                 raw_supp = index_to_support(backend, i)
                 # ensure the support satisfies parameter bounds and then add it
                 con_idx = i.I[group_idxs]
-                if _support_in_restrictions(constr, raw_supp)
+                if _support_in_restrictions(constr, raw_supp[pref_supp_idxs])
                     new_name = if isempty(name)
                         ""
                     elseif isempty(group_idxs)
@@ -849,7 +867,6 @@ function transcribe_constraints!(
         end
         # truncate the arrays in case not all the supports satisfied the bounds
         # and save
-        data = transcription_data(backend)
         if !all(valid_idxs)
             data.constr_mappings[cref] = crefs[valid_idxs]
             data.constr_supports[cref] = supps[valid_idxs]
diff --git a/src/array_parameters.jl b/src/array_parameters.jl
index ed22dcb5..63dbb01d 100644
--- a/src/array_parameters.jl
+++ b/src/array_parameters.jl
@@ -303,10 +303,7 @@ function add_parameters(
     end
     # make the parameter model object
     group_int_idx = length(parameter_group_indices(model)) + 1
-    first_param_num = model.last_param_num + 1
-    last_param_num = model.last_param_num += num_params
-    param_nums = first_param_num:last_param_num
-    data_object = MultiParameterData(params, group_int_idx, param_nums, names)
+    data_object = MultiParameterData(params, group_int_idx, names)
     # add the data object to the model and make the references
     obj_index = _add_data_object(model, data_object)
     # reset the name dictionary 
@@ -473,16 +470,6 @@ end
 ################################################################################
 #                          PARAMETER OBJECT METHODS
 ################################################################################
-# Extend _parameter_number
-function _parameter_number(pref::DependentParameterRef)
-    return _data_object(pref).parameter_nums[_param_index(pref)]
-end
-
-# Extend _parameter_numbers
-function _parameter_numbers(pref::DependentParameterRef)
-    return [_parameter_number(pref)]
-end
-
 """
     parameter_group_int_index(pref::DependentParameterRef)::Int
 
@@ -508,12 +495,16 @@ end
 # Reconstruction is necessary 
 function _adaptive_data_update(pref::DependentParameterRef, params::P1, 
     data::MultiParameterData{P2})  where {P1, P2}
-    new_data = MultiParameterData(params, data.group_int_idx, data.parameter_nums, 
-                                  data.names, data.parameter_func_indices,
-                                  data.infinite_var_indices, 
-                                  data.measure_indices,
-                                  data.constraint_indices,
-                                  data.has_internal_supports)
+    new_data = MultiParameterData(
+        params, 
+        data.group_int_idx, 
+        data.names, 
+        data.parameter_func_indices,
+        data.infinite_var_indices, 
+        data.measure_indices,
+        data.constraint_indices,
+        data.has_internal_supports
+    )
     _data_dictionary(pref)[JuMP.index(pref).object_index] = new_data
     return
 end
@@ -1661,10 +1652,9 @@ function JuMP.delete(
     end
     # get the object and parameter numbers
     group_int_idx = parameter_group_int_index(first(prefs))
-    param_nums = collect(_data_object(first(prefs)).parameter_nums)
     # delete parameter information stored in model
     _delete_data_object(first(prefs))
-    # update the parameter group integer indices and parameter numbers
-    _update_model_numbers(model, group_int_idx, param_nums)
+    # update the parameter group integer indices
+    _update_group_int_indices(model, group_int_idx)
     return
 end
diff --git a/src/datatypes.jl b/src/datatypes.jl
index e3eef2ae..db021232 100644
--- a/src/datatypes.jl
+++ b/src/datatypes.jl
@@ -553,8 +553,6 @@ A mutable `DataType` for storing `ScalarParameter`s and their data.
 - `parameter::P`: The scalar parameter.
 - `group_int_idx::Int`: The location of the corresponding `ObjectIndex` in
     `InfiniteModel.param_group_indices`.
-- `parameter_num::Int`: Given by `InfiniteModel.last_param_num` (updated when
-                        prior parameters are deleted)
 - `name::String`: The name used for printing.
 - `parameter_func_indices::Vector{ParameterFunctionIndex}`: Indices of dependent
    infinite parameter functions.
@@ -573,7 +571,6 @@ A mutable `DataType` for storing `ScalarParameter`s and their data.
 mutable struct ScalarParameterData{P <: ScalarParameter} <: AbstractDataObject
     parameter::P
     group_int_idx::Int
-    parameter_num::Int
     name::String
     parameter_func_indices::Vector{ParameterFunctionIndex}
     infinite_var_indices::Vector{InfiniteVariableIndex}
@@ -591,13 +588,11 @@ end
 function ScalarParameterData(
     param::P,
     group_int_idx::Int,
-    parameter_num::Int,
     name::String = ""
     ) where {P <: ScalarParameter}
     return ScalarParameterData{P}(
         param,
         group_int_idx,
-        parameter_num,
         name,
         ParameterFunctionIndex[],
         InfiniteVariableIndex[], 
@@ -621,8 +616,6 @@ A mutable `DataType` for storing [`DependentParameters`](@ref) and their data.
 - `parameters::P`: The parameter collection.
 - `group_int_idx::Int`: The location of the corresponding `ObjectIndex` in
    `InfiniteModel.param_group_indices`.
-- `parameter_nums::UnitRange{Int}`: Given by `InfiniteModel.last_param_num`
-                                    (updated when prior parameters are deleted)
 - `names::Vector{String}`: The names used for printing each parameter.
 - `parameter_func_indices::Vector{ParameterFunctionIndex}`: Indices of
    dependent infinite parameter functions.
@@ -637,7 +630,6 @@ A mutable `DataType` for storing [`DependentParameters`](@ref) and their data.
 mutable struct MultiParameterData{P <: DependentParameters} <: AbstractDataObject
     parameters::P
     group_int_idx::Int
-    parameter_nums::UnitRange{Int}
     names::Vector{String}
     parameter_func_indices::Vector{ParameterFunctionIndex}
     infinite_var_indices::Vector{InfiniteVariableIndex}
@@ -650,13 +642,12 @@ end
 function MultiParameterData(
     params::P,
     group_int_idx::Int,
-    parameter_nums::UnitRange{Int},
     names::Vector{String},
     ) where {P <: DependentParameters}
     return MultiParameterData{P}(
         params,
         group_int_idx,
-        parameter_nums, names,
+        names,
         ParameterFunctionIndex[], 
         InfiniteVariableIndex[],
         [MeasureIndex[] for i in eachindex(names)],
@@ -695,13 +686,11 @@ vectorized form of the support that comes from `support::VectorTuple` via:
                         inputs to `func`. Their formatting is analagous 
                         to those of infinite variables. 
 - `group_int_idxs::Vector{Int}`: The parameter group integer indices associated with `parameter_refs`.
-- `parameter_nums::Vector{Int}`: The parameter numbers of `parameter_refs`.
 """
 struct ParameterFunction{F <: Function, T <: JuMP.AbstractVariableRef}
     func::F
     parameter_refs::Collections.VectorTuple{T}
     group_int_idxs::Vector{Int}
-    parameter_nums::Vector{Int}
 end
 
 """
@@ -760,7 +749,6 @@ infinite parameter support that matches the format encoded in `parameter_refs`.
 - `info::JuMP.VariableInfo{LB, UB, FX, ST}`: JuMP variable information.
 - `parameter_refs::Collections.VectorTuple{T}`: The infinite parameter references that parameterize the 
   variable.
-- `parameter_nums::Vector{Int}`: The parameter numbers of `parameter_refs`.
 - `group_int_idxs::Vector{Int}`: The parameter group integer indices associated
   with `parameter_refs`.
 """
@@ -773,7 +761,6 @@ struct InfiniteVariable{
     } <: JuMP.AbstractVariable
     info::JuMP.VariableInfo{LB, UB, FX, ST} 
     parameter_refs::Collections.VectorTuple{T}
-    parameter_nums::Vector{Int}
     group_int_idxs::Vector{Int}
 end
 
@@ -815,8 +802,6 @@ infinite variable.
 - `eval_support::Vector{Float64}`: The evaluated parameter values that corresponds 
     to the vectorized infinite parameters of `infinite_variable_ref`. Any infinite 
     parameter not replaced by a value is represented with a `NaN`.
-- `parameter_nums::Vector{Int}`: The parameter numbers associated with the evaluated
-                                 `parameter_refs`.
 - `group_int_idxs::Vector{Int}`: The parameter group integer indices associated with the
                               evaluated `parameter_refs`.
 """
@@ -826,7 +811,6 @@ struct SemiInfiniteVariable{
     info::RestrictedDomainInfo
     infinite_variable_ref::I
     eval_support::Vector{Float64}
-    parameter_nums::Vector{Int}
     group_int_idxs::Vector{Int}
 end
 
@@ -1172,10 +1156,6 @@ and is enacted on `func` when the measure is evaluated (expended).
 - `group_int_idxs::Vector{Int}`: The parameter group integer indices of the evaluated
                               measure expression (i.e., the group integer indices of
                               `func` excluding those that belong to `data`).
-- `parameter_nums::Vector{Int}`: The parameter numbers that parameterize the
-                                 evaluated measure expression. (i.e., the
-                                 parameter numbers of `func` excluding those
-                                 that belong to `data`).
 - `constant_func::Bool`: Indicates if `func` is not parameterized by the infinite
                          parameters in `data`. (i.e., do the group integer indices of
                          `func` and `data` have no intersection?) This is useful
@@ -1185,7 +1165,6 @@ struct Measure{T <: JuMP.AbstractJuMPScalar, V <: AbstractMeasureData}
     func::T
     data::V
     group_int_idxs::Vector{Int}
-    parameter_nums::Vector{Int}
     constant_func::Bool
 end
 
@@ -1393,7 +1372,6 @@ mutable struct InfiniteModel <: JuMP.AbstractModel
     dependent_params::MOIUC.CleverDict{DependentParametersIndex, MultiParameterData}
     finite_params::MOIUC.CleverDict{FiniteParameterIndex, ScalarParameterData{FiniteParameter}}
     name_to_param::Union{Dict{String, AbstractInfOptIndex}, Nothing}
-    last_param_num::Int
     param_group_indices::Vector{Union{IndependentParameterIndex, DependentParametersIndex}}
     param_functions::MOIUC.CleverDict{ParameterFunctionIndex, <:ParameterFunctionData}
     piecewise_vars::Dict{IndependentParameterIndex, Set{InfiniteVariableIndex}}
@@ -1494,7 +1472,7 @@ function InfiniteModel(backend::AbstractTransformationBackend = TranscriptionBac
         MOIUC.CleverDict{IndependentParameterIndex, ScalarParameterData{<:IndependentParameter}}(),
         MOIUC.CleverDict{DependentParametersIndex, MultiParameterData}(),
         MOIUC.CleverDict{FiniteParameterIndex, ScalarParameterData{FiniteParameter}}(),
-        nothing, 0,
+        nothing,
         Union{IndependentParameterIndex, DependentParametersIndex}[],
         MOIUC.CleverDict{ParameterFunctionIndex, ParameterFunctionData{<:ParameterFunction}}(),
         Dict{IndependentParameterIndex, Set{InfiniteVariableIndex}}(),
@@ -1566,7 +1544,6 @@ function Base.empty!(model::InfiniteModel)
     empty!(model.dependent_params)
     empty!(model.finite_params)
     model.name_to_param = nothing
-    model.last_param_num = 0
     empty!(model.param_group_indices)
     empty!(model.param_functions)
     empty!(model.piecewise_vars)
@@ -1600,9 +1577,6 @@ function Base.empty!(model::InfiniteModel)
     return model
 end
 
-# Define basic accessors
-_last_param_num(model::InfiniteModel) = model.last_param_num
-
 """
     parameter_group_indices(model::InfiniteModel)::Vector{Union{IndependentParameterIndex, DependentParametersIndex}}
 
@@ -1629,7 +1603,7 @@ function _make_param_tuple_element(
     model::InfiniteModel,
     idx::DependentParametersIndex,
     )
-    num_params = length(model.dependent_params[idx].parameter_nums)
+    num_params = length(model.dependent_params[idx].names)
     return [GeneralVariableRef(model, idx.value, DependentParameterIndex, i)
             for i in 1:num_params]
 end
diff --git a/src/derivatives.jl b/src/derivatives.jl
index 3dc31a2e..fa099a2a 100644
--- a/src/derivatives.jl
+++ b/src/derivatives.jl
@@ -119,11 +119,6 @@ function parameter_group_int_indices(dref::DerivativeRef)
     return parameter_group_int_indices(derivative_argument(dref))
 end
 
-# Extend _parameter_numbers
-function _parameter_numbers(dref::DerivativeRef)
-    return _parameter_numbers(derivative_argument(dref))
-end
-
 # Get derivative index for variable-parameter pair if one exists 
 function _existing_derivative_index(
     vref::GeneralVariableRef, 
@@ -249,9 +244,8 @@ function build_derivative(
     end
     # check and format the info correctly
     prefs = raw_parameter_refs(argument_ref)
-    param_nums = _parameter_numbers(argument_ref)
     group_int_idxs = parameter_group_int_indices(argument_ref)
-    new_info = _check_and_format_infinite_info(_error, info, prefs, param_nums, group_int_idxs)
+    new_info = _check_and_format_infinite_info(_error, info, prefs, group_int_idxs)
     if new_info.binary || new_info.integer
         _error("Derivatives cannot be defined as binary or integer variables.")
     end
diff --git a/src/expressions.jl b/src/expressions.jl
index 24736318..2b4759a2 100644
--- a/src/expressions.jl
+++ b/src/expressions.jl
@@ -138,22 +138,6 @@ function parameter_group_int_indices(expr)
     return collect(group_int_idxs)
 end
 
-## Return the unique set of parameter numbers in an expression
-# Dispatch fallback (--> should be defined for each non-empty variable type)
-_parameter_numbers(v::DispatchVariableRef) = Int[]
-
-# GeneralVariableRef
-function _parameter_numbers(v::GeneralVariableRef)
-    return _parameter_numbers(dispatch_variable_ref(v))
-end
-
-# Other
-function _parameter_numbers(expr)
-    param_nums = Set{Int}()
-    _interrogate_variables(v -> union!(param_nums, _parameter_numbers(v)), expr)
-    return collect(param_nums)
-end
-
 ################################################################################
 #                            VARIABLE REMOVAL BOUNDS
 ################################################################################
diff --git a/src/general_variables.jl b/src/general_variables.jl
index ec8f1c00..4ba7417a 100644
--- a/src/general_variables.jl
+++ b/src/general_variables.jl
@@ -420,26 +420,6 @@ end
 ################################################################################
 #                              PARAMETER METHODS
 ################################################################################
-"""
-    _parameter_number(pref::DispatchVariableRef)::Int
-
-Return the parameter creation number for `pref` assuming it is an infinite
-parameter. This needs to be defined for the type of `pref`. This should use
-the `_data_object` to get the number.
-"""
-function _parameter_number end
-
-"""
-    _parameter_number(pref::GeneralVariableRef)::Int
-
-Return the parameter creation number for `pref` assuming it is an infinite
-parameter. It relies on `_parameter_number` being properly defined for the
-underlying `DispatchVariableRef`, otherwise an `MethodError` is thrown.
-"""
-function _parameter_number(pref::GeneralVariableRef)::Int
-    return _parameter_number(dispatch_variable_ref(pref))
-end
-
 """
     parameter_group_int_index(pref::DispatchVariableRef)::Int
 
diff --git a/src/infinite_variables.jl b/src/infinite_variables.jl
index 2db4c45e..e4d69c56 100644
--- a/src/infinite_variables.jl
+++ b/src/infinite_variables.jl
@@ -62,11 +62,6 @@ function parameter_group_int_indices(vref::InfiniteVariableRef)
     return core_object(vref).group_int_idxs
 end
 
-# Extend _parameter_numbers
-function _parameter_numbers(vref::InfiniteVariableRef)
-    return core_object(vref).parameter_nums
-end
-
 ## Set helper methods for adapting data_objects with parametric changes 
 # No change needed 
 function _adaptive_data_update(
@@ -202,7 +197,6 @@ function _process_info_arg(
     _error::Function,
     value::Real,
     prefs::Collections.VectorTuple,
-    param_nums::Vector{Int},
     group_idxs::Vector{Int},
     ) 
     return convert(Float64, value)
@@ -211,11 +205,10 @@ function _process_info_arg(
     _error::Function,
     func::Function,
     prefs::Collections.VectorTuple,
-    param_nums::Vector{Int},
     group_idxs::Vector{Int},
     )
     _check_param_func_method(_error, func, prefs)
-    return ParameterFunction(func, prefs, group_idxs, param_nums)
+    return ParameterFunction(func, prefs, group_idxs)
 end
 
 ## Check and format the variable info considering functional start values
@@ -229,18 +222,17 @@ function _check_and_format_infinite_info(
         <:Union{Real, Function}
         },
     prefs::Collections.VectorTuple,
-    param_nums::Vector{Int},
     group_int_idxs::Vector{Int},
     )
     return JuMP.VariableInfo(
         info.has_lb,
-        _process_info_arg(_error, info.lower_bound, prefs, param_nums, group_int_idxs), 
+        _process_info_arg(_error, info.lower_bound, prefs, group_int_idxs), 
         info.has_ub,
-        _process_info_arg(_error, info.upper_bound, prefs, param_nums, group_int_idxs),
+        _process_info_arg(_error, info.upper_bound, prefs, group_int_idxs),
         info.has_fix,
-        _process_info_arg(_error, info.fixed_value, prefs, param_nums, group_int_idxs),
+        _process_info_arg(_error, info.fixed_value, prefs, group_int_idxs),
         info.has_start,
-        _process_info_arg(_error, info.start, prefs, param_nums, group_int_idxs),
+        _process_info_arg(_error, info.start, prefs, group_int_idxs),
         info.binary, 
         info.integer
     )
@@ -251,7 +243,6 @@ function _check_and_format_infinite_info(
     _error::Function,
     info::JuMP.VariableInfo,
     prefs::Collections.VectorTuple,
-    param_nums::Vector{Int},
     group_int_idxs::Vector{Int},
     )
     _error("Unrecognized formatting for the variable domain information.")
@@ -293,11 +284,10 @@ function JuMP.build_variable(
     for pref in prefs 
         union!(group_int_idxs, parameter_group_int_index(pref))
     end
-    param_nums = [_parameter_number(pref) for pref in prefs]
     # check and format the info
-    new_info = _check_and_format_infinite_info(_error, info, prefs, param_nums, group_int_idxs)
+    new_info = _check_and_format_infinite_info(_error, info, prefs, group_int_idxs)
     # make the variable and return
-    return InfiniteVariable(new_info, prefs, param_nums, group_int_idxs)
+    return InfiniteVariable(new_info, prefs, group_int_idxs)
 end
 
 # check the pref tuple contains only valid parameters
@@ -624,9 +614,8 @@ function _update_variable_info(
     info::JuMP.VariableInfo
     )
     prefs = raw_parameter_refs(vref)
-    param_nums = _parameter_numbers(vref)
     group_int_idxs = parameter_group_int_indices(vref)
-    new_var = InfiniteVariable(info, prefs, param_nums, group_int_idxs)
+    new_var = InfiniteVariable(info, prefs, group_int_idxs)
     _set_core_object(vref, new_var)
     return
 end
@@ -637,9 +626,8 @@ function _process_info_arg(
     func::Function
     )
     prefs = raw_parameter_refs(vref)
-    param_nums = _parameter_numbers(vref)
     group_int_idxs = parameter_group_int_indices(vref)
-    return _process_info_arg(error, func, prefs, param_nums, group_int_idxs)
+    return _process_info_arg(error, func, prefs, group_int_idxs)
 end
 
 ################################################################################
diff --git a/src/measures.jl b/src/measures.jl
index 82a96ce4..0d17382f 100644
--- a/src/measures.jl
+++ b/src/measures.jl
@@ -62,11 +62,6 @@ function parameter_group_int_indices(mref::MeasureRef)
     return core_object(mref).group_int_idxs
 end
 
-# Extend _parameter_numbers
-function _parameter_numbers(mref::MeasureRef)
-    return core_object(mref).parameter_nums
-end
-
 ## Set helper methods for adapting data_objects with parametric changes 
 # No change needed 
 function _adaptive_data_update(
@@ -757,20 +752,17 @@ function build_measure(
     data::AbstractMeasureData
     )
     expr_group_int_idxs = parameter_group_int_indices(expr)
-    expr_param_nums = _parameter_numbers(expr)
     prefs = parameter_refs(data)
     data_group_int_idxs = parameter_group_int_indices(prefs)
-    data_param_nums = [_parameter_number(pref) for pref in prefs]
     # NOTE setdiff! cannot be used here since it modifies group_int_idxs of expr if expr is a single infinite variable
     group_int_idxs = sort(setdiff(expr_group_int_idxs, data_group_int_idxs))
-    param_nums = sort(setdiff(expr_param_nums, data_param_nums))
     # check if analytic method should be applied
     lb_nan = isnan(first(JuMP.lower_bound(data)))
     ub_nan = isnan(first(JuMP.upper_bound(data)))
-    # NOTE intersect! cannot be used here since it modifies parameter_nums of expr if expr is a single infinite variable
-    constant_func = isempty(intersect(expr_param_nums, data_param_nums)) &&
+    # NOTE intersect! cannot be used here since it modifies idxs of expr if expr is a single infinite variable
+    constant_func = isempty(intersect(expr_group_int_idxs, data_group_int_idxs)) &&
                     ((!lb_nan && !ub_nan) || _is_expect(data))
-    return Measure(expr, data, group_int_idxs, param_nums, constant_func)
+    return Measure(expr, data, group_int_idxs, constant_func)
 end
 
 ################################################################################
@@ -1366,7 +1358,7 @@ function JuMP.delete(model::InfiniteModel, mref::MeasureRef)
         data = measure_data(meas_ref)
         if func isa GeneralVariableRef
             new_func = zero(JuMP.GenericAffExpr{Float64, GeneralVariableRef})
-            new_meas = Measure(new_func, data, Int[], Int[], false)
+            new_meas = Measure(new_func, data, Int[], false)
         else
             _remove_variable(func, gvref)
             new_meas = build_measure(func, data)
diff --git a/src/parameter_functions.jl b/src/parameter_functions.jl
index f39952b9..1cdc4084 100644
--- a/src/parameter_functions.jl
+++ b/src/parameter_functions.jl
@@ -49,11 +49,6 @@ function parameter_group_int_indices(fref::ParameterFunctionRef)
     return core_object(fref).group_int_idxs
 end
 
-# Extend _parameter_numbers
-function _parameter_numbers(fref::ParameterFunctionRef)
-    return core_object(fref).parameter_nums
-end
-
 ################################################################################
 #                                 DEFINITION
 ################################################################################
@@ -131,10 +126,8 @@ function build_parameter_function(
         parameter_group_int_index(prefs[i, 1])
         for i in 1:size(prefs, 1)
     ]
-    # get the parameter numbers 
-    param_nums = [_parameter_number(pref) for pref in prefs]
     # make the variable and return
-    return ParameterFunction(func, prefs, group_int_idxs, param_nums)
+    return ParameterFunction(func, prefs, group_int_idxs)
 end
 
 # Fallback for weird macro inputs
@@ -363,7 +356,6 @@ function JuMP.set_parameter_value(
     new_pfunc = ParameterFunction(
         func, 
         old_pfunc.parameter_refs, 
-        old_pfunc.parameter_nums,
         old_pfunc.group_int_idxs
     )
     old_data_object = _data_object(fref)
@@ -588,7 +580,7 @@ function JuMP.delete(model::InfiniteModel, fref::ParameterFunctionRef)
         data = measure_data(mref)
         if func isa GeneralVariableRef
             new_func = zero(JuMP.GenericAffExpr{Float64, GeneralVariableRef})
-            new_meas = Measure(new_func, data, Int[], Int[], true)
+            new_meas = Measure(new_func, data, Int[], true)
         else
             _remove_variable(func, gvref)
             new_meas = build_measure(func, data)
diff --git a/src/scalar_parameters.jl b/src/scalar_parameters.jl
index 9670f256..8965c38b 100644
--- a/src/scalar_parameters.jl
+++ b/src/scalar_parameters.jl
@@ -85,16 +85,6 @@ function core_object(pref::FiniteParameterRef)
     return _data_object(pref).parameter
 end
 
-# Extend _parameter_number
-function _parameter_number(pref::IndependentParameterRef)
-    return _data_object(pref).parameter_num
-end
-
-# Extend _parameter_numbers
-function _parameter_numbers(pref::IndependentParameterRef)
-    return [_parameter_number(pref)]
-end
-
 """
     `parameter_group_int_index(pref::IndependentParameterRef)::Int
 
@@ -126,15 +116,21 @@ function _adaptive_data_update(
     param::P1, 
     data::ScalarParameterData{P2}
     )  where {P1, P2}
-    new_data = ScalarParameterData(param, data.group_int_idx, data.parameter_num, 
-                                   data.name, data.parameter_func_indices,
-                                   data.infinite_var_indices, 
-                                   data.derivative_indices, data.measure_indices,
-                                   data.constraint_indices, data.in_objective,
-                                   data.generative_measures,
-                                   data.has_internal_supports, 
-                                   data.has_generative_supports,
-                                   data.has_deriv_constrs)
+    new_data = ScalarParameterData(
+        param, 
+        data.group_int_idx,
+        data.name, 
+        data.parameter_func_indices,
+        data.infinite_var_indices, 
+        data.derivative_indices, 
+        data.measure_indices,
+        data.constraint_indices, 
+        data.in_objective,
+        data.generative_measures,
+        data.has_internal_supports, 
+        data.has_generative_supports,
+        data.has_deriv_constrs
+    )
     _data_dictionary(pref)[JuMP.index(pref)] = new_data
     return
 end
@@ -312,8 +308,7 @@ function add_parameter(
     name::String = ""
     )
     group_int_idx = length(parameter_group_indices(model)) + 1
-    param_num = model.last_param_num += 1
-    data_object = ScalarParameterData(p, group_int_idx, param_num, name)
+    data_object = ScalarParameterData(p, group_int_idx, name)
     obj_index = _add_data_object(model, data_object)
     model.name_to_param = nothing
     return GeneralVariableRef(model, obj_index.value, typeof(obj_index))
@@ -343,7 +338,7 @@ function add_parameter(
     p::FiniteParameter,
     name::String = ""
     )
-    data_object = ScalarParameterData(p, -1, -1, name)
+    data_object = ScalarParameterData(p, -1, name)
     obj_index = _add_data_object(model, data_object)
     model.name_to_param = nothing
     return GeneralVariableRef(model, obj_index.value, typeof(obj_index))
@@ -574,8 +569,7 @@ function _update_param_name_dict(
     ) where {K, V <: MultiParameterData}
     name_dict = _param_name_dict(model)
     for (index, data_object) in param_dict
-        param_nums = data_object.parameter_nums
-        for i in eachindex(param_nums)
+        for i in eachindex(data_object.names)
             name = data_object.names[i]
             if haskey(name_dict, name)
                 # IndependentParameterIndex(-1) is a special value that means
@@ -1617,7 +1611,7 @@ function _update_measures(model::InfiniteModel, pref::GeneralVariableRef)
         if func isa GeneralVariableRef
             data = measure_data(mref)
             new_func = zero(JuMP.GenericAffExpr{Float64, GeneralVariableRef})
-            new_meas = Measure(new_func, data, Int[], Int[], true)
+            new_meas = Measure(new_func, data, Int[], true)
             _set_core_object(mref, new_meas)
         else
             _remove_variable(func, pref)
@@ -1658,45 +1652,38 @@ function _update_number_list(nums::Vector{Int}, list::Vector{Int})
     return
 end
 
-# Update the model with the removed parameter number(s) and parameter group index
-function _update_model_numbers(
+# Update the model with the removed parameter group indices
+function _update_group_int_indices(
     model::InfiniteModel,
     group_int_idx::Int,
-    param_nums::Vector{Int}
     )
     # update the independent parameters
     for (_, object) in _data_dictionary(model, IndependentParameter)
         if object.group_int_idx > group_int_idx
             object.group_int_idx -= 1
-            object.parameter_num -= length(param_nums)
         end
     end
     # update the dependent parameters
     for (_, object) in _data_dictionary(model, DependentParameters)
         if object.group_int_idx > group_int_idx
             object.group_int_idx -= 1
-            object.parameter_nums = object.parameter_nums .- length(param_nums)
         end
     end
     # update the infinite parameter functions
     for (_, object) in model.param_functions
         _update_number_list([group_int_idx], object.func.group_int_idxs)
-        _update_number_list(param_nums, object.func.parameter_nums)
     end
     # update the infinite variables
     for vref in JuMP.all_variables(model, InfiniteVariable)
         _update_number_list([group_int_idx], parameter_group_int_indices(vref))
-        _update_number_list(param_nums, _parameter_numbers(vref))
     end
     # update the semi-infinite variables
     for vref in JuMP.all_variables(model, SemiInfiniteVariable)
         _update_number_list([group_int_idx], parameter_group_int_indices(vref))
-        _update_number_list(param_nums, _parameter_numbers(vref))
     end
     # update the measures
     for mref in all_measures(model)
         _update_number_list([group_int_idx], parameter_group_int_indices(mref))
-        _update_number_list(param_nums, _parameter_numbers(mref))
     end
     # update the constraints
     for (_, object) in model.constraints
@@ -1704,7 +1691,6 @@ function _update_model_numbers(
     end
     # update the central info
     deleteat!(parameter_group_indices(model), group_int_idx)
-    model.last_param_num -= length(param_nums)
     return
 end
 
@@ -1759,10 +1745,9 @@ function JuMP.delete(model::InfiniteModel, pref::IndependentParameterRef)
     _update_constraints(model, gvref)
     # delete parameter information stored in model
     group_int_idx = parameter_group_int_index(pref)
-    param_nums = _parameter_numbers(pref)
     _delete_data_object(pref)
-    # update the parameter group integer indices and parameter numbers
-    _update_model_numbers(model, group_int_idx, param_nums)
+    # update the parameter group integer indices
+    _update_group_int_indices(model, group_int_idx)
     return
 end
 
diff --git a/src/semi_infinite_variables.jl b/src/semi_infinite_variables.jl
index e200ef03..7ca8e1d8 100644
--- a/src/semi_infinite_variables.jl
+++ b/src/semi_infinite_variables.jl
@@ -78,11 +78,6 @@ function parameter_group_int_indices(vref::SemiInfiniteVariableRef)
     return core_object(vref).group_int_idxs
 end
 
-# Extend _parameter_numbers
-function _parameter_numbers(vref::SemiInfiniteVariableRef)
-    return core_object(vref).parameter_nums
-end
-
 ################################################################################
 #                             DEFINITION METHODS
 ################################################################################
@@ -253,10 +248,6 @@ function JuMP.build_variable(
         for (i, idx) in enumerate(parameter_group_int_indices(dvref))
         if isnan(eval_support[raw_prefs.ranges[i].start])
     ]
-    # get the parameter numbers
-    orig_nums = _parameter_numbers(ivref)
-    param_nums = [orig_nums[i] for i in eachindex(orig_nums)
-                  if isnan(eval_support[i])]
     # round the support values in accordance with the significant digits
     for i in eachindex(eval_support)
         eval_support[i] = round(
@@ -269,7 +260,6 @@ function JuMP.build_variable(
         restricted_info,
         ivref,
         eval_support,
-        param_nums, 
         group_int_idxs
     )
 end
@@ -519,7 +509,6 @@ function _update_variable_info(
         info,
         var.infinite_variable_ref,
         var.eval_support,
-        var.parameter_nums,
         var.group_int_idxs
         )
     _set_core_object(vref, new_var)
diff --git a/src/variable_basics.jl b/src/variable_basics.jl
index 2e30108a..1ec7033e 100644
--- a/src/variable_basics.jl
+++ b/src/variable_basics.jl
@@ -114,8 +114,7 @@ function JuMP.add_variable(
     pfunc = ParameterFunction(
         (s...) -> val,
         var.parameter_refs,
-        var.group_int_idxs,
-        var.parameter_nums
+        var.group_int_idxs
     )
     return add_parameter_function(model, pfunc, name)
 end
@@ -141,8 +140,7 @@ function JuMP.add_variable(
     pfunc = ParameterFunction(
         func,
         var.parameter_refs,
-        var.group_int_idxs,
-        var.parameter_nums
+        var.group_int_idxs
     )
     return add_parameter_function(model, pfunc, name)
 end
@@ -389,8 +387,7 @@ function _process_restricted_value(
     return ParameterFunction(
         new_func,
         raw_parameter_refs(var),
-        var.group_int_idxs, 
-        var.parameter_nums
+        var.group_int_idxs
     )
 end
 
@@ -1573,7 +1570,7 @@ function JuMP.delete(model::InfiniteModel, vref::DecisionVariableRef)
         data = measure_data(mref)
         if func isa GeneralVariableRef
             new_func = zero(JuMP.GenericAffExpr{Float64, GeneralVariableRef})
-            new_meas = Measure(new_func, data, Int[], Int[], true)
+            new_meas = Measure(new_func, data, Int[], true)
         else
             _remove_variable(func, gvref)
             new_meas = build_measure(func, data)
diff --git a/test/TranscriptionOpt/measure.jl b/test/TranscriptionOpt/measure.jl
index 8146ab3c..4968f167 100644
--- a/test/TranscriptionOpt/measure.jl
+++ b/test/TranscriptionOpt/measure.jl
@@ -28,6 +28,9 @@
     data.infvar_supports[y0] = [(0., [0., 0.]), (0., [1., 1.])]
     data.infvar_lookup[y0] = Dict([0, 0, 0] => a, [0, 1, 1] => b)
     data.finvar_mappings[x0] = a
+    data.infvar_param_idxs[pf] = [1]
+    data.infvar_param_idxs[x] = [1]
+    data.infvar_param_idxs[y] = [1, 2, 3]
     IOTO.set_parameter_supports(tb, m)
     # test make_point_variable_ref
     @testset "make_point_variable_ref" begin
@@ -60,11 +63,11 @@
     # test add_semi_infinite_variable
     @testset "add_semi_infinite_variable" begin
         # add one that was already added to the infinite model
-        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [0.0, NaN, NaN], [2, 3], [2])
+        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [0.0, NaN, NaN], [2])
         @test isequal(InfiniteOpt.add_semi_infinite_variable(tb, var), y0)
         @test IOTO.transcription_variable(y0) == [a, b]
         # add a new one
-        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [1.0, NaN, NaN], [2, 3], [2])
+        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [1.0, NaN, NaN], [2])
         vref = GeneralVariableRef(m, -1, SemiInfiniteVariableIndex)
         @test isequal(InfiniteOpt.add_semi_infinite_variable(tb, var), vref)
         @test isequal(data.semi_infinite_vars, [var])
diff --git a/test/TranscriptionOpt/model.jl b/test/TranscriptionOpt/model.jl
index 60a34485..f60c58e2 100644
--- a/test/TranscriptionOpt/model.jl
+++ b/test/TranscriptionOpt/model.jl
@@ -486,6 +486,10 @@ end
     data.pfunc_lookup[f] = Dict([0, 0, 0] => 0.5, [1, 0, 0] => 0.7)
     data.measure_lookup[meas1] = Dict(Float64[] => 1)
     data.measure_lookup[meas2] = Dict([0] => 1, [1] => 2)
+    data.infvar_param_idxs[x] = [3, 1, 2]
+    data.infvar_param_idxs[f] = [3, 1, 2]
+    data.infvar_param_idxs[meas2] = [3]
+    data.infvar_param_idxs[meas1] = []
     @test IOTO.set_parameter_supports(tb, m) isa Nothing
     # test IOTO.transcription_expression in accordance with the methods defined in transcribe.jl
     @testset "IOTO.transcription_expression (Fallback)" begin
@@ -504,12 +508,14 @@ end
                           add_support = false)
         data.infvar_mappings[rv] = [0.7]
         data.pfunc_lookup[rv] = Dict([0, 0] => 0.7)
+        data.infvar_param_idxs[rv] = [1, 2]
         @test IOTO.transcription_expression(rv, tb, [0., 0., 1.]) == 0.7
         # semi_infinite of infinite variable
         rv = add_variable(m, build_variable(error, x, [1, NaN, NaN]),
                           add_support = false)
         data.infvar_mappings[rv] = [b]
         data.infvar_lookup[rv] = Dict([0, 0] => b)
+        data.infvar_param_idxs[rv] = [1, 2]
         @test IOTO.transcription_expression(rv, tb, [0., 0., 1.]) == b
     end
     # test transcription expression for finite variables with 3 args
diff --git a/test/TranscriptionOpt/transcribe.jl b/test/TranscriptionOpt/transcribe.jl
index f6e1d66e..374364fd 100644
--- a/test/TranscriptionOpt/transcribe.jl
+++ b/test/TranscriptionOpt/transcribe.jl
@@ -290,11 +290,11 @@ end
     end
     # test _support_in_restrictions
     @testset "_support_in_restrictions" begin 
-        @test IOTO._support_in_restrictions(constraint_object(c1), [0., 0., 0.])
-        @test IOTO._support_in_restrictions(constraint_object(c2), [0., 0., 0.])
-        @test !IOTO._support_in_restrictions(constraint_object(c2), [0, 0., 1.])
+        @test IOTO._support_in_restrictions(constraint_object(c1), Float64[])
+        @test IOTO._support_in_restrictions(constraint_object(c2), [0.])
+        @test !IOTO._support_in_restrictions(constraint_object(c2), [1.])
         @test IOTO._support_in_restrictions(constraint_object(c3), [1., 1., 1.])
-        @test !IOTO._support_in_restrictions(constraint_object(c3), [1., 1., 0.])
+        @test !IOTO._support_in_restrictions(constraint_object(c3), [0., 1., 1.])
     end
     # test _process_constraint
     @testset "_process_constraint" begin
diff --git a/test/array_parameters.jl b/test/array_parameters.jl
index 5aebd839..c8c5867c 100644
--- a/test/array_parameters.jl
+++ b/test/array_parameters.jl
@@ -6,7 +6,7 @@
     idx = DependentParameterIndex(obj_idx, 1)
     domain = CollectionDomain([IntervalDomain(0, 1), IntervalDomain(0, 1)])
     params = DependentParameters(domain, OrderedDict{Vector{Float64}, Set{DataType}}(), 5)
-    object = MultiParameterData(params, 1, 1:2, ["p1", "p2"])
+    object = MultiParameterData(params, 1, ["p1", "p2"])
     pref = DependentParameterRef(m, idx)
     gvref = GeneralVariableRef(m, 1, DependentParameterIndex, 1)
     bad_idx = DependentParameterIndex(DependentParametersIndex(-1), 2)
@@ -137,21 +137,18 @@ end
         params = InfiniteOpt._build_parameters(error, [domain1, domain1], inds1)
         @test isequal(add_parameters(m, params, ["", ""]), prefs)
         @test InfiniteOpt.parameter_group_indices(m) == [index(prefs[1]).object_index]
-        @test InfiniteOpt._last_param_num(m) == 2
         @test name.(prefs) == ["", ""]
         # test vector build
         prefs = [GeneralVariableRef(m, 2, DependentParameterIndex, i) for i in 1:2]
         params = InfiniteOpt._build_parameters(error, [domain2, domain2], inds1)
         @test isequal(add_parameters(m, params, ["p1", "p2"]), prefs)
         @test InfiniteOpt.parameter_group_indices(m)[2] == index(prefs[1]).object_index
-        @test InfiniteOpt._last_param_num(m) == 4
         @test name.(prefs) == ["p1", "p2"]
         # test array build
         prefs = [GeneralVariableRef(m, 3, DependentParameterIndex, i) for i in 1:4]
         params = InfiniteOpt._build_parameters(error, [domain3 for i in 1:4], inds2)
         @test isequal(add_parameters(m, params, ["p$i" for i in 1:4]), prefs)
         @test InfiniteOpt.parameter_group_indices(m)[3] == index(prefs[1]).object_index
-        @test InfiniteOpt._last_param_num(m) == 8
         @test name.(prefs) == ["p$i" for i in 1:4]
         # test name error 
         @test_throws ErrorException add_parameters(m, params, ["p"])
@@ -416,19 +413,6 @@ end
     params = DependentParameters(domain, OrderedDict{Vector{Float64}, Set{DataType}}(), 10)
     bad_idx = DependentParameterIndex(DependentParametersIndex(-1), 2)
     bad_pref = DependentParameterRef(m, bad_idx)
-    # test _parameter_number
-    @testset "_parameter_number" begin
-        @test InfiniteOpt._parameter_number(prefs[1]) == 1
-        @test InfiniteOpt._parameter_number(prefs[2]) == 2
-        @test InfiniteOpt._parameter_number(gvrefs[1]) == 1
-        @test_throws ErrorException InfiniteOpt._parameter_number(bad_pref)
-    end
-    # test _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(prefs[1]) == [1]
-        @test InfiniteOpt._parameter_numbers(prefs[2]) == [2]
-        @test InfiniteOpt._parameter_numbers(gvrefs[1]) == [1]
-    end
     # test parameter_group_int_index
     @testset "parameter_group_int_index" begin
         @test InfiniteOpt.parameter_group_int_index(prefs[1]) == 1
diff --git a/test/datatypes.jl b/test/datatypes.jl
index 04380e57..458fe64e 100644
--- a/test/datatypes.jl
+++ b/test/datatypes.jl
@@ -168,12 +168,12 @@ end
                               OrderedDict(zeros(1) => Set([All])), 6).domain isa CollectionDomain
     # test ScalarParameterData
     @test ScalarParameterData <: AbstractDataObject
-    @test ScalarParameterData(FiniteParameter(42), 1, 1, "bob").name == "bob"
+    @test ScalarParameterData(FiniteParameter(42), 1, "bob").name == "bob"
     # test MultiParameterData
     @test MultiParameterData <: AbstractDataObject
     params = DependentParameters(CollectionDomain([IntervalDomain(0, 1)]),
                                  OrderedDict(zeros(1) => Set([All])), 6)
-    @test MultiParameterData(params, 1, 1:1, ["par[1]"]) isa MultiParameterData
+    @test MultiParameterData(params, 1, ["par[1]"]) isa MultiParameterData
 end
 
 # Test Backends
@@ -197,7 +197,6 @@ end
     @test InfiniteModel() isa JuMP.AbstractModel
     @test InfiniteModel(mockoptimizer, add_bridges = false) isa InfiniteModel
     # test accessors
-    @test InfiniteOpt._last_param_num(m) == 0
     @test InfiniteOpt.parameter_group_indices(m) isa Vector{Union{IndependentParameterIndex, DependentParametersIndex}}
     # test other methods 
     @test empty!(InfiniteModel(mockoptimizer)).backend isa TranscriptionBackend
@@ -267,9 +266,9 @@ end
     pref = GeneralVariableRef(m, 1, IndependentParameterIndex, -1)
     vt = IC.VectorTuple(pref)
     # test ParameterFunction
-    @test ParameterFunction(sin, vt, [1], [1]) isa ParameterFunction
+    @test ParameterFunction(sin, vt, [1]) isa ParameterFunction
     # test ParameterFunctionData
-    @test ParameterFunctionData(ParameterFunction(sin, vt, [1], [1])) isa ParameterFunctionData
+    @test ParameterFunctionData(ParameterFunction(sin, vt, [1])) isa ParameterFunctionData
 end
 
 # Test variable datatypes
@@ -280,16 +279,16 @@ end
     sample_info = VariableInfo(true, num, true, num, true, num, true, num, true, true)
     pref = GeneralVariableRef(m, 1, IndependentParameterIndex, -1)
     func = (x) -> NaN
-    pfunc = ParameterFunction(func, IC.VectorTuple(pref), [1], [1])
+    pfunc = ParameterFunction(func, IC.VectorTuple(pref), [1])
     inf_info = VariableInfo(true, num, true, pfunc, true, num, false, pfunc, true, true)
     vref = GeneralVariableRef(m, 1, InfiniteVariableIndex)
     # Infinite variable
     @test InfiniteVariable <: JuMP.AbstractVariable
-    @test InfiniteVariable(inf_info, IC.VectorTuple(pref), [1], [1]) isa InfiniteVariable
+    @test InfiniteVariable(inf_info, IC.VectorTuple(pref), [1]) isa InfiniteVariable
     # Semi-Infinite variable
     @test RestrictedDomainInfo() isa RestrictedDomainInfo
     @test SemiInfiniteVariable <: JuMP.AbstractVariable
-    @test SemiInfiniteVariable(RestrictedDomainInfo(), vref, [0.5], [1], [1]) isa SemiInfiniteVariable
+    @test SemiInfiniteVariable(RestrictedDomainInfo(), vref, [0.5], [1]) isa SemiInfiniteVariable
     # Point variable
     @test PointVariable <: JuMP.AbstractVariable
     @test PointVariable(RestrictedDomainInfo(), vref, Float64[1]) isa PointVariable
@@ -305,7 +304,7 @@ end
     num = Float64(0)
     pref = GeneralVariableRef(m, 1, IndependentParameterIndex, -1)
     func = (x) -> NaN
-    pfunc = ParameterFunction(func, IC.VectorTuple(pref), [1], [1])
+    pfunc = ParameterFunction(func, IC.VectorTuple(pref), [1])
     inf_info = VariableInfo(true, pfunc, true, num, true, num, false, pfunc, true, true)
     vref = GeneralVariableRef(m, 1, InfiniteVariableIndex)
     dref = GeneralVariableRef(m, 1, DerivativeIndex)
@@ -313,7 +312,7 @@ end
     @test Derivative <: JuMP.AbstractVariable
     @test Derivative(inf_info, vref, pref, 1) isa Derivative
     # Semi-infinite derivative
-    @test SemiInfiniteVariable(RestrictedDomainInfo(), dref, [0.5], [1], [1]) isa SemiInfiniteVariable
+    @test SemiInfiniteVariable(RestrictedDomainInfo(), dref, [0.5], [1]) isa SemiInfiniteVariable
     # Point derivative
     @test PointVariable(RestrictedDomainInfo(), dref, Float64[1]) isa PointVariable
     # VariableData
@@ -342,11 +341,11 @@ end
     @test Measure isa UnionAll
     @test Measure(zero(AffExpr),
                   DiscreteMeasureData(pref, ones(2), ones(2), All, w, NaN, NaN, false),
-                  [1], [1], false) isa Measure
+                  [1], false) isa Measure
     # MeasureData
     @test MeasureData <: AbstractDataObject
     @test MeasureData(Measure(zero(AffExpr), DiscreteMeasureData(pref,
-                      ones(2), ones(2), All, w, NaN, NaN, false), [1], [1], true)) isa MeasureData
+                      ones(2), ones(2), All, w, NaN, NaN, false), [1], true)) isa MeasureData
 end
 
 # Test the constraint datatypes
@@ -358,7 +357,7 @@ end
     # DomainRestrictedConstraint
     @test DomainRestriction((p) -> true, pref) isa DomainRestriction
     @test DomainRestrictedConstraint <: JuMP.AbstractConstraint
-    pfunc = ParameterFunction((x) -> true, IC.VectorTuple(pref), [1], [1])
+    pfunc = ParameterFunction((x) -> true, IC.VectorTuple(pref), [1])
     @test DomainRestrictedConstraint(con, pfunc).restriction == pfunc
     # ConstraintData
     @test ConstraintData <: AbstractDataObject
diff --git a/test/deletion.jl b/test/deletion.jl
index 7fd8842b..3e304a9c 100644
--- a/test/deletion.jl
+++ b/test/deletion.jl
@@ -200,12 +200,10 @@ end
         @test isequal(measure_function(dmref2), zero(JuMP.GenericAffExpr{Float64, GeneralVariableRef}))
         @test InfiniteOpt.parameter_group_int_indices(dmref) == [2, 3, 4]
         @test InfiniteOpt.parameter_group_int_indices(dmref2) == []
-        @test InfiniteOpt._parameter_numbers(dmref) == [2, 3, 4, 5]
-        @test InfiniteOpt._parameter_numbers(dmref2) == []
         # undo changes
-        meas = Measure(inf + par - x + rv + par2 + par3 + fin, data, [2, 4], [2, 5], false)
+        meas = Measure(inf + par - x + rv + par2 + par3 + fin, data, [2, 4], false)
         InfiniteOpt._set_core_object(dmref, meas)
-        meas = Measure(par2, data, [2], [2], false)
+        meas = Measure(par2, data, [2], false)
         InfiniteOpt._set_core_object(dmref2, meas)
     end
     # test _update_constraints
@@ -259,18 +257,12 @@ end
         expected = [IndependentParameterIndex(1), DependentParametersIndex(1),
                     IndependentParameterIndex(3)]
         @test InfiniteOpt.parameter_group_indices(m) == expected
-        @test InfiniteOpt._last_param_num(m) == 4
         @test InfiniteOpt.parameter_group_int_index(dpar) == 1
         @test InfiniteOpt.parameter_group_int_index(dpars[1]) == 2
         @test InfiniteOpt.parameter_group_int_index(dpar3) == 3
-        @test InfiniteOpt._parameter_number(dpar3) == 4
-        @test InfiniteOpt._parameter_number(dpars[2]) == 3
-        @test InfiniteOpt._parameter_numbers(dinf4) == [1, 2, 3]
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(inf3), [1, 2]))
-        @test InfiniteOpt._parameter_numbers(dinf) == [1]
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(drv), [1, 2]))
         @test InfiniteOpt.parameter_group_int_indices(dmref) == [3]
-        @test InfiniteOpt._parameter_numbers(dmref) == [4]
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(con), [1, 2, 3]))
         @test isempty(InfiniteOpt.parameter_group_int_indices(con2))
         @test !is_valid(m, con3)
@@ -282,9 +274,6 @@ end
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(con), [1, 2]))
         expected = [IndependentParameterIndex(1), DependentParametersIndex(1)]
         @test InfiniteOpt.parameter_group_indices(m) == expected
-        @test InfiniteOpt._last_param_num(m) == 3
-        @test InfiniteOpt._parameter_number(dpars[2]) == 3
-        @test InfiniteOpt._parameter_numbers(dinf4) == [1, 2, 3]
         # test invalid parameter
         @test_throws AssertionError delete(m, par2)
         @test_throws AssertionError delete(m, par3)
@@ -372,14 +361,10 @@ end
         @test isequal_canonical(jump_function(constraint_object(con)), inf2 - par2)
         expected = [IndependentParameterIndex(1), IndependentParameterIndex(2)]
         @test InfiniteOpt.parameter_group_indices(m) == expected
-        @test InfiniteOpt._last_param_num(m) == 2
         @test InfiniteOpt.parameter_group_int_index(dpar) == 1
         @test InfiniteOpt.parameter_group_int_index(dpar2) == 2
-        @test InfiniteOpt._parameter_number(dpar2) == 2
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(dinf2), [1, 2]))
-        @test InfiniteOpt._parameter_numbers(dinf) == [1]
         @test InfiniteOpt.parameter_group_int_indices(dmref) == []
-        @test InfiniteOpt._parameter_numbers(dmref) == []
         @test isempty(setdiff(InfiniteOpt.parameter_group_int_indices(con), [1, 2]))
         @test !is_valid(m, con2)
         # test assertion error
diff --git a/test/derivatives.jl b/test/derivatives.jl
index 9debe676..5dbfc8d3 100644
--- a/test/derivatives.jl
+++ b/test/derivatives.jl
@@ -71,10 +71,6 @@
     @testset "parameter_group_int_indices" begin
         @test InfiniteOpt.parameter_group_int_indices(dref) == [1]
     end
-    # _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(dref) == [1]
-    end
     # test _variable_info
     @testset "_variable_info" begin
         @test InfiniteOpt._variable_info(dref) == info
@@ -443,7 +439,7 @@ end
         rvref = gvref(pref, [1, 0])
         @test @deriv(rvref, pref) isa GeneralVariableRef    
         # test with measures 
-        meas = Measure(w, TestData(pref, 0, 1), [2], [2], false)
+        meas = Measure(w, TestData(pref, 0, 1), [2], false)
         data = MeasureData(meas, "meas")
         @test InfiniteOpt._add_data_object(m, data) isa MeasureIndex
         mref = GeneralVariableRef(m, 1, MeasureIndex)
diff --git a/test/expressions.jl b/test/expressions.jl
index 9f6cc6b8..c011494f 100644
--- a/test/expressions.jl
+++ b/test/expressions.jl
@@ -4,7 +4,7 @@
     m = InfiniteModel()
     @infinite_parameter(m, t in [0, 1])
     @infinite_parameter(m, x[1:2] in [-1, 1])
-    func = ParameterFunction(sin, IC.VectorTuple(t), [1], [1])
+    func = ParameterFunction(sin, IC.VectorTuple(t), [1])
     object = ParameterFunctionData(func, "test")
     idx = ParameterFunctionIndex(1)
     fref = ParameterFunctionRef(m, idx)
@@ -54,10 +54,6 @@
     @testset "parameter_group_int_indices" begin
         @test InfiniteOpt.parameter_group_int_indices(fref) == [1]
     end
-    # _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(fref) == [1]
-    end
     # JuMP.name
     @testset "JuMP.name" begin
         @test name(fref) == "test"
@@ -431,7 +427,7 @@ end
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -550,64 +546,6 @@ end
     end
 end
 
-# Test _parameter_numbers
-@testset "_parameter_numbers" begin
-    # initialize model and references
-    m = InfiniteModel()
-    @infinite_parameter(m, par in [0, 1])
-    @infinite_parameter(m, pars[1:2] in [0, 1])
-    @variable(m, inf, Infinite(par))
-    @variable(m, inf2, Infinite(par, pars))
-    @variable(m, pt, Point(inf, 0))
-    @variable(m, finite)
-    var = build_variable(error, inf2, [0.5, NaN, NaN], check = false)
-    red = add_variable(m, var)
-    # test for finite variable reference
-    @testset "FiniteVariable" begin
-        @test InfiniteOpt._parameter_numbers(pt) == []
-        @test InfiniteOpt._parameter_numbers(finite) == []
-    end
-    # test for infinite variable reference
-    @testset "InfiniteVariable" begin
-        @test InfiniteOpt._parameter_numbers(inf) == [1]
-        @test InfiniteOpt._parameter_numbers(inf2) == [1, 2, 3]
-    end
-    # test for parameter reference
-    @testset "Parameter" begin
-        @test InfiniteOpt._parameter_numbers(par) == [1]
-        @test InfiniteOpt._parameter_numbers(pars[2]) == [3]
-    end
-    # test for semi-infinite variable reference
-    @testset "SemiInfiniteInfinite" begin
-        @test InfiniteOpt._parameter_numbers(red) == [2, 3]
-    end
-    # test for GenericAffExpr
-    @testset "AffExpr" begin
-        # make expressions
-        aff1 = inf + inf2 + pt - 3
-        aff2 = pt + finite - 2
-        # test expressions
-        @test sort!(InfiniteOpt._parameter_numbers(aff1)) == [1, 2, 3]
-        @test InfiniteOpt._parameter_numbers(aff2) == []
-    end
-    # test for GenericQuadExpr
-    @testset "QuadExpr" begin
-        # make expressions
-        quad1 = inf * inf2 + inf + inf2 + pt - 3 - par
-        quad2 = pt * pt + pt + finite - 2
-        # test expressions
-        @test sort!(InfiniteOpt._parameter_numbers(quad1)) == [1, 2, 3]
-        @test InfiniteOpt._parameter_numbers(quad2) == []
-    end
-    # test for GenericNonlinearExpr
-    @testset "GenericNonlinearExpr" begin
-        # make expressions
-        nlp = sin(inf2)
-        # test expressions
-        @test sort!(InfiniteOpt._parameter_numbers(nlp)) == [1, 2, 3]
-    end
-end
-
 # Test _remove_variable
 @testset "_remove_variable" begin
     # initialize model and references
diff --git a/test/general_variables.jl b/test/general_variables.jl
index 5d87a4fa..4bcc11e5 100644
--- a/test/general_variables.jl
+++ b/test/general_variables.jl
@@ -247,10 +247,6 @@ end
               GeneralVariableRef(m, 2, TestIndex)]
     sdomain = IntervalDomain(0, 1)
     adomain = CollectionDomain([sdomain, sdomain])
-    # test _parameter_number
-    @testset "_parameter_number" begin
-        @test_throws MethodError InfiniteOpt._parameter_number(gvref)
-    end
     # test parameter_group_int_index
     @testset "parameter_group_int_index" begin
         @test_throws MethodError InfiniteOpt.parameter_group_int_index(gvref)
diff --git a/test/infinite_variables.jl b/test/infinite_variables.jl
index fb1cbd25..72fb3332 100644
--- a/test/infinite_variables.jl
+++ b/test/infinite_variables.jl
@@ -8,17 +8,14 @@
     @infinite_parameter(m, d in [0, 1])
     idx = InfiniteVariableIndex(1)
     group_idxs = [1, 3, 5, 6]
-    param_idxs = [1, 3, 5, 6, 7]
     num = Float64(0)
     func = (x...) -> 1
-    pfunc = ParameterFunction(func, IC.VectorTuple(a, b[2], c, d), group_idxs, param_idxs)
+    pfunc = ParameterFunction(func, IC.VectorTuple(a, b[2], c, d), group_idxs)
     info = VariableInfo(false, num, false, num, false, num, false, pfunc, false, false)
     new_info = VariableInfo(true, 0., true, 0., true, pfunc, true, num, true, false)
     new_info2 = VariableInfo(true, 0., true, pfunc, true, 0., true, num, true, false)
-    var = InfiniteVariable(info, IC.VectorTuple(a, b[2], c, d),
-                           param_idxs, group_idxs)
-    var2 = InfiniteVariable(new_info, IC.VectorTuple(a, b[2], c, d),
-                            param_idxs, group_idxs)
+    var = InfiniteVariable(info, IC.VectorTuple(a, b[2], c, d), group_idxs)
+    var2 = InfiniteVariable(new_info, IC.VectorTuple(a, b[2], c, d), group_idxs)
     object = VariableData(var, "var")
     vref = InfiniteVariableRef(m, idx)
     gvref = GeneralVariableRef(m, 1, InfiniteVariableIndex)
@@ -74,10 +71,6 @@
     @testset "parameter_group_int_indices" begin
         @test InfiniteOpt.parameter_group_int_indices(vref) == group_idxs
     end
-    # _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(vref) == param_idxs
-    end
     # test _variable_info
     @testset "_variable_info" begin
         @test InfiniteOpt._variable_info(vref) == info
@@ -238,24 +231,22 @@ end
     # _check_and_format_infinite_info (Real)
     @testset "_check_and_format_infinite_info" begin
         tuple = IC.VectorTuple((pref, prefs, pref2))
-        param_idxs = [1, 3, 4, 2]
         group_idxs = [1, 3, 2]
-        @test !InfiniteOpt._check_and_format_infinite_info(error, info, tuple, param_idxs, group_idxs).has_start
-        @test InfiniteOpt._check_and_format_infinite_info(error, info2, tuple, param_idxs, group_idxs).start isa ParameterFunction
-        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, param_idxs, group_idxs).start == 42
-        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, param_idxs, group_idxs).has_lb
-        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, param_idxs, group_idxs).lower_bound isa ParameterFunction
+        @test !InfiniteOpt._check_and_format_infinite_info(error, info, tuple, group_idxs).has_start
+        @test InfiniteOpt._check_and_format_infinite_info(error, info2, tuple, group_idxs).start isa ParameterFunction
+        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, group_idxs).start == 42
+        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, group_idxs).has_lb
+        @test InfiniteOpt._check_and_format_infinite_info(error, info3, tuple, group_idxs).lower_bound isa ParameterFunction
         bad_func(a, b) = 2
         bad_info = VariableInfo(true, num, true, num, true, num, true, bad_func, true, false)
-        @test_throws ErrorException InfiniteOpt._check_and_format_infinite_info(error, bad_info, tuple, param_idxs, group_idxs)
+        @test_throws ErrorException InfiniteOpt._check_and_format_infinite_info(error, bad_info, tuple, group_idxs)
     end
     # _check_and_format_infinite_info (Fallback)
     @testset "_check_and_format_infinite_info (Fallback)" begin
         tuple = IC.VectorTuple((pref, prefs, pref2))
-        param_idxs = [1, 3, 4, 2]
         group_idxs = [1, 3, 2]
         bad_info = VariableInfo(true, num, true, num, true, num, true, Complex(1), true, false)
-        @test_throws ErrorException InfiniteOpt._check_and_format_infinite_info(error, bad_info, tuple, param_idxs, group_idxs)
+        @test_throws ErrorException InfiniteOpt._check_and_format_infinite_info(error, bad_info, tuple, group_idxs)
     end
     # build_variable
     @testset "JuMP.build_variable" begin
@@ -273,7 +264,6 @@ end
         @test isequal(build_variable(error, info, Infinite(pref, prefs)).parameter_refs, tuple)
         tuple = IC.VectorTuple(prefs)
         @test isequal(build_variable(error, info, Infinite(prefs)).parameter_refs, tuple)
-        @test isequal(build_variable(error, info, Infinite(prefs)).parameter_nums, [3, 4])
         @test isequal(build_variable(error, info, Infinite(prefs)).group_int_idxs, [3])
     end
     # _check_parameters_valid
@@ -694,7 +684,7 @@ end
         @test is_used(vref)
         empty!(InfiniteOpt._point_variable_dependencies(vref))
         # test used by semi-infinite variable
-        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [0.5, NaN, NaN], [2], [2])
+        var = SemiInfiniteVariable(RestrictedDomainInfo(), y, [0.5, NaN, NaN], [2])
         object = VariableData(var, "var")
         idx = SemiInfiniteVariableIndex(1)
         rvref = SemiInfiniteVariableRef(m, idx)
diff --git a/test/macro_expressions.jl b/test/macro_expressions.jl
index 8fcbb021..e1f74cd2 100644
--- a/test/macro_expressions.jl
+++ b/test/macro_expressions.jl
@@ -7,7 +7,7 @@
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -95,7 +95,7 @@ end
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -183,7 +183,7 @@ end
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -271,7 +271,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -420,7 +420,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -528,7 +528,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -634,7 +634,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -752,7 +752,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -871,7 +871,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
diff --git a/test/measures.jl b/test/measures.jl
index 64262aa3..306efadc 100644
--- a/test/measures.jl
+++ b/test/measures.jl
@@ -5,7 +5,7 @@
     @infinite_parameter(m, t in [0, 1])
     w = t -> 1
     meas_data = DiscreteMeasureData(t, ones(2), ones(2), All, w, NaN, NaN, false)
-    meas = Measure(zero(AffExpr),meas_data, [1], [1], false)
+    meas = Measure(zero(AffExpr),meas_data, [1], false)
     object = MeasureData(meas)
     idx = MeasureIndex(1)
     mref = MeasureRef(m, idx)
@@ -33,11 +33,6 @@
         @test core_object(mref) == meas
         @test core_object(gvref) == meas
     end
-    # test _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(mref) == [1]
-        @test InfiniteOpt._parameter_numbers(gvref) == [1]
-    end
     # test parameter_group_int_indices
     @testset "parameter_group_int_indices" begin
         @test InfiniteOpt.parameter_group_int_indices(mref) == [1]
@@ -522,7 +517,7 @@ end
     end
     # test add_measure
     @testset "add_measure" begin
-        meas1 = Measure(par + 2inf - x, data1, [1], [1], false)
+        meas1 = Measure(par + 2inf - x, data1, [1], false)
         mref1 = MeasureRef(m, MeasureIndex(1))
         @test isequal(dispatch_variable_ref(add_measure(m, meas1, "measure1")), mref1)
         @test supports(par) == [1.0]
@@ -541,7 +536,7 @@ end
     @variable(m, inf, Infinite(par))
     @variable(m, x)
     data = DiscreteMeasureData(par, [1], [1])
-    meas = Measure(par + 2inf - x, data, [1], [1], false)
+    meas = Measure(par + 2inf - x, data, [1], false)
     mref = add_measure(m, meas)
     # test measure_function
     @testset "measure_function" begin
diff --git a/test/operators.jl b/test/operators.jl
index e291f02c..19829533 100644
--- a/test/operators.jl
+++ b/test/operators.jl
@@ -8,7 +8,7 @@
     @variable(m, finite)
     dinf = @deriv(inf, par)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -94,7 +94,7 @@ end
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -176,7 +176,7 @@ end
     @variable(m, pt, Point(inf, 0))
     @variable(m, finite)
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -259,7 +259,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -403,7 +403,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -504,7 +504,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -605,7 +605,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -718,7 +718,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
@@ -831,7 +831,7 @@ end
     @variable(m, finite)
     @variable(m, test[1:51])
     data = TestData(par, 0, 5)
-    meas = Measure(finite, data, Int[], Int[], true)
+    meas = Measure(finite, data, Int[], true)
     object = MeasureData(meas, "test")
     mindex = MeasureIndex(1)
     @test InfiniteOpt._add_data_object(m, object) == mindex
diff --git a/test/scalar_parameters.jl b/test/scalar_parameters.jl
index 15a2f91a..5b5a8503 100644
--- a/test/scalar_parameters.jl
+++ b/test/scalar_parameters.jl
@@ -10,8 +10,8 @@
     info = NoGenerativeSupports()
     ind_param = IndependentParameter(domain, supps_dict, 5, method, info)
     fin_param = FiniteParameter(42)
-    ind_object = ScalarParameterData(ind_param, 1, 1, "ind")
-    fin_object = ScalarParameterData(fin_param, -1, -1, "fin")
+    ind_object = ScalarParameterData(ind_param, 1, "ind")
+    fin_object = ScalarParameterData(fin_param, -1, "fin")
     ind_pref = IndependentParameterRef(m, ind_idx)
     fin_pref = FiniteParameterRef(m, fin_idx)
     ind_gvref = GeneralVariableRef(m, 1, IndependentParameterIndex)
@@ -56,16 +56,6 @@
         @test core_object(fin_pref) == fin_param
         @test core_object(fin_gvref) == fin_param
     end
-    # test _parameter_number
-    @testset "_parameter_number" begin
-        @test InfiniteOpt._parameter_number(ind_pref) == 1
-        @test InfiniteOpt._parameter_number(ind_gvref) == 1
-    end
-    # test _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(ind_pref) == [1]
-        @test InfiniteOpt._parameter_numbers(ind_gvref) == [1]
-    end
     # test parameter_group_int_index
     @testset "parameter_group_int_index" begin
         @test InfiniteOpt.parameter_group_int_index(ind_pref) == 1
diff --git a/test/semi_infinite_variables.jl b/test/semi_infinite_variables.jl
index f1989926..a0f5a0e1 100644
--- a/test/semi_infinite_variables.jl
+++ b/test/semi_infinite_variables.jl
@@ -7,7 +7,7 @@
     @infinite_parameter(m, c[1:2] in [0, 1])
     @variable(m, ivref, Infinite(a, b..., c))
     eval_supp = [0.5, NaN, 1., 0., 0.]
-    var = SemiInfiniteVariable(RestrictedDomainInfo(), ivref, eval_supp, [2], [2])
+    var = SemiInfiniteVariable(RestrictedDomainInfo(), ivref, eval_supp, [2])
     object = VariableData(var, "var")
     idx = SemiInfiniteVariableIndex(1)
     vref = SemiInfiniteVariableRef(m, idx)
@@ -77,10 +77,6 @@
     @testset "parameter_group_int_indices" begin
         @test InfiniteOpt.parameter_group_int_indices(vref) == [2]
     end
-    # _parameter_numbers
-    @testset "_parameter_numbers" begin
-        @test InfiniteOpt._parameter_numbers(vref) == [2]
-    end
     # infinite_variable_ref
     @testset "infinite_variable_ref" begin
         @test isequal(infinite_variable_ref(vref), ivref)
@@ -219,7 +215,6 @@ end
         new_info = RestrictedDomainInfo(true, 1., false, NaN, false, NaN, true, 42.)
         @test build_variable(error, ivref, eval_supp, new_info).info.lower_bound == 1
         @test build_variable(error, ivref, eval_supp, check = false).group_int_idxs == [2]
-        @test build_variable(error, ivref, eval_supp, check = false).parameter_nums == [2]
     end
     # test JuMP.add_variable
     @testset "JuMP.add_variable" begin
diff --git a/test/utilities.jl b/test/utilities.jl
index a6c6ded9..268fd7df 100644
--- a/test/utilities.jl
+++ b/test/utilities.jl
@@ -131,20 +131,6 @@ function InfiniteOpt.add_supports_to_parameters(d::TestData)::Nothing
 end
 InfiniteOpt.support_label(d::TestData) = UniqueMeasure{:a}
 
-# Define useful function for deletion testing
-function _update_variable_param_refs(vref::InfiniteVariableRef,
-                                     prefs::IC.VectorTuple{GeneralVariableRef}
-                                     )::Nothing
-    # get basic information
-    info = InfiniteOpt._variable_info(vref)
-    param_nums = [InfiniteOpt._parameter_number(pref) for pref in prefs]
-    # get the parameter group integer indices
-    group_int_idxs = InfiniteOpt.parameter_group_int_indices(parameter_list(prefs))
-    is_vect_func = InfiniteOpt._is_vector_start(vref)
-    new_var = InfiniteVariable(info, prefs, param_nums, group_int_idxs, is_vect_func)
-    InfiniteOpt._set_core_object(vref, new_var)
-    return
-end
 
 function Base.isequal(nlp1::GenericNonlinearExpr, nlp2::GenericNonlinearExpr)
     return nlp1.head == nlp2.head && isequal(nlp1.args, nlp2.args)